1 /*

     2  * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 package shapegen;

    25 

    26 import shapegen.ClassCase.Kind;

    27 

    28 import java.util.Collection;

    29 import java.util.Set;

    30 import java.util.HashSet;

    31 import java.util.Collections;

    32 import java.util.ArrayList;

    33 import java.util.List;

    34 

    35 import static shapegen.ClassCase.Kind.*;

    36 

    37 import static java.lang.Math.pow;

    38 

    39 /**

    40  *

    41  * @author Robert Field

    42  */

    43 public final class HierarchyGenerator {

    44 

    45     private int okcnt = 0;

    46     private int errcnt = 0;

    47     private Set<Hierarchy> uniqueOK = new HashSet<>();

    48     private Set<Hierarchy> uniqueErr = new HashSet<>();

    49 

    50     /**

    51      * @param args the command line arguments

    52      */

    53     public HierarchyGenerator() {

    54         organize("exhaustive interface", iExhaustive(2));

    55         organize("exhaustive class", cExhaustive());

    56         organize("shapes interface", iShapes());

    57         organize("shapes class/interface", ciShapes());

    58 

    59         System.out.printf("\nExpect OK:    %d -- unique %d",   okcnt,  uniqueOK.size());

    60         System.out.printf("\nExpect Error: %d -- unique %d\n", errcnt, uniqueErr.size());

    61     }

    62 

    63     public Collection<Hierarchy> getOK() {

    64         return uniqueOK;

    65     }

    66 

    67     public Collection<Hierarchy> getErr() {

    68         return uniqueErr;

    69     }

    70 

    71     private void organize(String tname, List<Hierarchy> totest) {

    72         System.out.printf("\nGenerating %s....\n", tname);

    73         int nodefault = 0;

    74         List<Hierarchy> ok = new ArrayList<>();

    75         List<Hierarchy> err = new ArrayList<>();

    76         for (Hierarchy cc : totest) {

    77             if (cc.anyDefaults()) {

    78                 //System.out.printf("  %s\n", cc);

    79                 if (cc.get_OK()) {

    80                     ok.add(cc);

    81                 } else {

    82                     err.add(cc);

    83                 }

    84             } else {

    85                 ++nodefault;

    86             }

    87         }

    88 

    89         errcnt += err.size();

    90         okcnt += ok.size();

    91         uniqueErr.addAll(err);

    92         uniqueOK.addAll(ok);

    93 

    94         System.out.printf("  %5d No default\n  %5d Error\n  %5d OK\n  %5d Total\n",

    95                 nodefault, err.size(), ok.size(), totest.size());

    96     }

    97 

    98     public List<Hierarchy> iExhaustive(int idepth) {

    99         List<ClassCase> current = new ArrayList<>();

   100         for (int i = 0; i < idepth; ++i) {

   101             current = ilayer(current);

   102         }

   103         return wrapInClassAndHierarchy(current);

   104     }

   105 

   106     private List<ClassCase> ilayer(List<ClassCase> srcLayer) {

   107         List<ClassCase> lay = new ArrayList<>();

   108         for (int i = (int) pow(2, srcLayer.size()) - 1; i >= 0; --i) {

   109             List<ClassCase> itfs = new ArrayList<>();

   110             for (int b = srcLayer.size() - 1; b >= 0; --b) {

   111                 if ((i & (1<<b)) != 0) {

   112                     itfs.add(srcLayer.get(b));

   113                 }

   114             }

   115             lay.add(new ClassCase(IVAC, null, itfs));

   116             lay.add(new ClassCase(IPRESENT, null, itfs));

   117             lay.add(new ClassCase(IDEFAULT, null, itfs));

   118             lay.add(new ClassCase(IDEFAULT, null, itfs));

   119         }

   120         return lay;

   121     }

   122 

   123     public List<Hierarchy> cExhaustive() {

   124         final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};

   125         final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};

   126         List<Hierarchy> totest = new ArrayList<>();

   127         for (int i1 = 0; i1 < iKinds.length; ++i1) {

   128             for (int i2 = 0; i2 < iKinds.length; ++i2) {

   129                 for (int i3 = 0; i3 < iKinds.length; ++i3) {

   130                     for (int c1 = 0; c1 < cKinds.length; ++c1) {

   131                         for (int c2 = 0; c2 < cKinds.length; ++c2) {

   132                             for (int c3 = 0; c3 < cKinds.length; ++c3) {

   133                                 totest.add( new Hierarchy(

   134                                         new ClassCase(cKinds[c1],

   135                                             new ClassCase(cKinds[c2],

   136                                                 new ClassCase(cKinds[c3],

   137                                                     null,

   138                                                     iList(iKinds[i1])

   139                                                 ),

   140                                                 iList(iKinds[i2])

   141                                             ),

   142                                             iList(iKinds[i3])

   143                                         )));

   144                             }

   145                         }

   146                     }

   147                 }

   148             }

   149         }

   150         return totest;

   151     }

   152 

   153     public static final List<ClassCase> EMPTY_LIST = new ArrayList<>();

   154 

   155     private List<ClassCase> iList(Kind kind) {

   156         if (kind == null) {

   157             return EMPTY_LIST;

   158         } else {

   159             List<ClassCase> itfs = new ArrayList<>();

   160             itfs.add(new ClassCase(kind, null, EMPTY_LIST));

   161             return itfs;

   162         }

   163     }

   164 

   165     public List<Hierarchy> ciShapes() {

   166         return wrapInHierarchy(TTShape.allCases(true));

   167     }

   168 

   169     public List<Hierarchy> iShapes() {

   170         return wrapInClassAndHierarchy(TTShape.allCases(false));

   171     }

   172 

   173     public List<Hierarchy> wrapInClassAndHierarchy(List<ClassCase> ihs) {

   174         List<Hierarchy> totest = new ArrayList<>();

   175         for (ClassCase cc : ihs) {

   176             List<ClassCase> interfaces = new ArrayList<>();

   177             interfaces.add(cc);

   178             totest.add(new Hierarchy(new ClassCase(CNONE, null, interfaces)));

   179         }

   180         return totest;

   181     }

   182 

   183     public List<Hierarchy> wrapInHierarchy(List<ClassCase> ihs) {

   184         List<Hierarchy> totest = new ArrayList<>();

   185         for (ClassCase cc : ihs) {

   186             totest.add(new Hierarchy(cc));

   187         }

   188         return totest;

   189     }

   190 }