| /******************************************************************************* |
| * Copyright (c) 2005, 2016 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Stephan Herrmann <stephan@cs.tu-berlin.de> - Contributions for |
| * bug 320170 |
| * bug 345305 - [compiler][null] Compiler misidentifies a case of "variable can only be null" |
| * bug 386181 - [compiler][null] wrong transition in UnconditionalFlowInfo.mergedWith() |
| * bug 395002 - Self bound generic class doesn't resolve bounds properly for wildcards for certain parametrisation. |
| * Bug 453635 - [compiler][null] Update NullReferenceImplTests and friends |
| *******************************************************************************/ |
| package org.eclipse.jdt.core.tests.compiler.regression; |
| |
| import java.io.BufferedReader; |
| import java.io.BufferedWriter; |
| import java.io.File; |
| import java.io.FileReader; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.Map; |
| import java.util.SortedMap; |
| import java.util.TreeMap; |
| |
| import junit.framework.AssertionFailedError; |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| |
| import org.eclipse.jdt.core.tests.compiler.regression.NullReferenceImplTests.State; |
| import org.eclipse.jdt.internal.compiler.flow.FlowInfo; |
| import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo; |
| import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo.AssertionFailedException; |
| import org.eclipse.jdt.internal.compiler.impl.Constant; |
| import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.PackageBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.Scope; |
| import org.eclipse.jdt.internal.compiler.lookup.TypeBinding; |
| |
| /** |
| * A tests series especially meant to validate the internals of our null |
| * reference analysis. See NullReferenceTest for tests targetted at |
| * the source code compiler behavior level. |
| */ |
| @SuppressWarnings({ "unchecked", "rawtypes" }) |
| public class NullReferenceImplTests extends NullReferenceTest { |
| // Static initializer to specify tests subset using TESTS_* static variables |
| // All specified tests which does not belong to the class are skipped... |
| // Only the highest compliance level is run; add the VM argument |
| // -Dcompliance=1.4 (for example) to lower it if needed |
| static { |
| // TESTS_NAMES = new String[] { "test2050" }; |
| // TESTS_NUMBERS = new int[] { 2061 }; |
| // TESTS_NUMBERS = new int[] { 2999 }; |
| // TESTS_RANGE = new int[] { 2050, -1 }; |
| } |
| |
| /** |
| * A class to hold states as seen by the low level validation tests and machinery. |
| * State provides: |
| * - singletons for all possible states given the number of bits for the said |
| * states; |
| * - semantic names for known states; |
| * - printable representation of states as bit fields; |
| * - coordination with other classes to perform transitive closure analysis, etc. |
| */ |
| /* |
| This is a tabular definition for states. It can be completed/leveraged by |
| the Generator class so as to smoothen the transition between differing encodings |
| of the states. |
| // STATES DEFINITION START |
| 000000 start |
| 000001 |
| 000010 |
| 000011 |
| 000100 pot. unknown |
| 000101 |
| 000110 |
| 000111 |
| 001000 pot. non null |
| 001001 |
| 001010 |
| 001011 |
| 001100 pot. nn & pot. un |
| 001101 |
| 001110 |
| 001111 |
| 010000 pot. null |
| 010001 |
| 010010 |
| 010011 |
| 010100 pot. n & pot. un |
| 010101 |
| 010110 |
| 010111 |
| 011000 pot. n & pot. nn |
| 011001 |
| 011010 |
| 011011 |
| 011100 pot. n & pot. nn & pot. un |
| 011101 |
| 011110 |
| 011111 |
| 100000 |
| 100001 |
| 100010 |
| 100011 |
| 100100 def. unknown |
| 100101 |
| 100110 |
| 100111 |
| 101000 def. non null |
| 101001 |
| 101010 |
| 101011 |
| 101100 pot. nn & prot. nn |
| 101101 |
| 101110 |
| 101111 |
| 110000 def. null |
| 110001 |
| 110010 |
| 110011 |
| 110100 pot. n & prot. n |
| 110101 |
| 110110 |
| 110111 |
| 111000 prot. null |
| 111001 |
| 111010 |
| 111011 |
| 111100 prot. non null |
| 111101 |
| 111110 |
| 111111 |
| // STATES DEFINITION END |
| */ |
| public static class State implements Comparable { |
| // PREMATURE consider moving initialization to test setup/dispose |
| public final static State[] states = { |
| // STATES INITIALIZER START |
| new State(0, "start"), // 000000 |
| new State(1), // 000001 |
| new State(2), // 000010 |
| new State(3), // 000011 |
| new State(4, "pot. unknown"), // 000100 |
| new State(5), // 000101 |
| new State(6), // 000110 |
| new State(7), // 000111 |
| new State(8, "pot. non null"), // 001000 |
| new State(9), // 001001 |
| new State(10), // 001010 |
| new State(11), // 001011 |
| new State(12, "pot. nn & pot. un"), // 001100 |
| new State(13), // 001101 |
| new State(14), // 001110 |
| new State(15), // 001111 |
| new State(16, "pot. null"), // 010000 |
| new State(17), // 010001 |
| new State(18), // 010010 |
| new State(19), // 010011 |
| new State(20, "pot. n & pot. un"), // 010100 |
| new State(21), // 010101 |
| new State(22), // 010110 |
| new State(23), // 010111 |
| new State(24, "pot. n & pot. nn"), // 011000 |
| new State(25), // 011001 |
| new State(26), // 011010 |
| new State(27), // 011011 |
| new State(28, "pot. n & pot. nn & pot. un"), // 011100 |
| new State(29), // 011101 |
| new State(30), // 011110 |
| new State(31), // 011111 |
| new State(32), // 100000 |
| new State(33), // 100001 |
| new State(34), // 100010 |
| new State(35), // 100011 |
| new State(36, "def. unknown"), // 100100 |
| new State(37), // 100101 |
| new State(38), // 100110 |
| new State(39), // 100111 |
| new State(40, "def. non null"), // 101000 |
| new State(41), // 101001 |
| new State(42), // 101010 |
| new State(43), // 101011 |
| new State(44, "pot. nn & prot. nn"), // 101100 |
| new State(45), // 101101 |
| new State(46), // 101110 |
| new State(47), // 101111 |
| new State(48, "def. null"), // 110000 |
| new State(49), // 110001 |
| new State(50), // 110010 |
| new State(51), // 110011 |
| new State(52, "pot. n & prot. n"), // 110100 |
| new State(53), // 110101 |
| new State(54), // 110110 |
| new State(55), // 110111 |
| new State(56, "prot. null"), // 111000 |
| new State(57), // 111001 |
| new State(58), // 111010 |
| new State(59), // 111011 |
| new State(60, "prot. non null"), // 111100 |
| new State(61), // 111101 |
| new State(62), // 111110 |
| new State(63), // 111111 |
| // STATES INITIALIZER END |
| }; |
| public final static State start = states[0]; |
| public static final int |
| stateMaxValue = 0x3F, |
| stateWidth = 6, |
| statesNb = stateMaxValue + 1; |
| String name, printableBitsField, hexString; |
| public byte value; |
| boolean symbolic; |
| private State() { |
| } |
| private State(int numericValue) { |
| this(numericValue, null); |
| } |
| private State(int numericValue, String publicName) { |
| if (numericValue > stateMaxValue) { |
| throw new IllegalArgumentException("state value overflow"); |
| } |
| this.value = (byte) numericValue; |
| StringBuffer printableValue = new StringBuffer(6); |
| for (int i = stateWidth - 1; i >= 0; i--) { |
| printableValue.append((numericValue >>> i & 1) != 0 ? '1' : '0'); |
| } |
| this.printableBitsField = printableValue.toString(); |
| if (this.value > 0xF) { |
| this.hexString = "0x" + Integer.toHexString(this.value).toUpperCase(); |
| } |
| else { |
| this.hexString = "0x0" + Integer.toHexString(this.value).toUpperCase(); |
| } |
| if (publicName != null) { |
| this.name = publicName; |
| this.symbolic = true; |
| } |
| else { |
| this.name = this.printableBitsField; |
| } |
| } |
| private State(String commentLine) { |
| char current = ' '; // keep the initialization status quiet |
| int cursor, length; |
| for (cursor = 0, length = commentLine.length(); |
| cursor < length; |
| cursor++) { |
| if ((current = commentLine.charAt(cursor)) == '0' || |
| current == '1') { |
| break; |
| } |
| } |
| if (cursor == length) { |
| throw new RuntimeException("bad state definition format (missing bits field): " + commentLine); |
| // PREMATURE adopt consistent error policy |
| } |
| int valueDigits; |
| for (valueDigits = 1; cursor < (length - 1) && valueDigits < stateWidth; valueDigits++) { |
| this.value = (byte) ((this.value << 1) + (current - '0')); |
| if ((current = commentLine.charAt(++cursor)) != '0' && |
| current != '1') { |
| throw new RuntimeException("bad state definition format (inappropriate character in bits field): " + commentLine); |
| // PREMATURE adopt consistent error policy |
| } |
| } |
| if (valueDigits < stateWidth) { |
| throw new RuntimeException("bad state definition format (bits field is too short): " + commentLine); |
| // PREMATURE adopt consistent error policy |
| } |
| this.value = (byte) ((this.value << 1) + (current - '0')); |
| this.printableBitsField = commentLine.substring(cursor - stateWidth + 1, cursor + 1); |
| if (this.value > 0xF) { |
| this.hexString = "0x" + Integer.toHexString(this.value).toUpperCase(); |
| } |
| else { |
| this.hexString = "0x0" + Integer.toHexString(this.value).toUpperCase(); |
| } |
| while (++cursor < length && Character.isWhitespace(current = commentLine.charAt(++cursor)) && current != '\n') { |
| // loop |
| } |
| if (cursor < length && current != '\n') { |
| this.name = commentLine.substring(cursor, length); |
| } |
| if (this.name == null) { |
| this.name = this.printableBitsField; |
| } else { |
| this.symbolic = true; |
| } |
| } |
| private String asInitializer() { |
| StringBuffer result = new StringBuffer(70); |
| result.append(" new State("); |
| result.append(this.value); |
| char first; |
| boolean nameIsSymbolic = (first = this.name.charAt(0)) != '0' |
| && first != '1'; |
| if (nameIsSymbolic) { |
| result.append(", \""); |
| result.append(this.name); |
| result.append('"'); |
| } |
| result.append("), // "); |
| result.append(this.printableBitsField); |
| return result.toString(); |
| } |
| long [] asLongArray() { |
| long[] result = new long[stateWidth]; |
| for (int i = 0; i < stateWidth; i++) { |
| result[i] = ((this.value >> (stateWidth - i - 1)) & 1) == 0 ? 0 : 1; |
| } |
| return result; |
| } |
| private String asSourceComment() { |
| StringBuffer result = new StringBuffer(70); |
| result.append("\t\t"); |
| result.append(this.printableBitsField); |
| char first; |
| boolean nameIsSymbolic = (first = this.name.charAt(0)) != '0' |
| && first != '1'; |
| if (nameIsSymbolic) { |
| result.append('\t'); |
| result.append(this.name); |
| } |
| return result.toString(); |
| } |
| public int compareTo(Object o) { |
| return this.value - ((State) o).value; |
| } |
| static State fromLongValues(long bit1, long bit2, long bit3, long bit4, long bit5, long bit6) { |
| // PREMATURE consider taking an UnconditionalFlowInfo in parameter |
| return states[(int)( |
| (bit6 & 1) + |
| 2 * ((bit5 & 1) + |
| 2 * ((bit4 & 1) + |
| 2 * ((bit3 & 1) + |
| 2 * ((bit2 & 1) + |
| 2 * (bit1 & 1))))))]; |
| } |
| private static Map namesIndex; |
| static State fromSymbolicName (String name) { |
| if (namesIndex == null) { |
| namesIndex = new HashMap(states.length); |
| for (int i = 0; i < states.length; i++) { |
| if (states[i].name != null) { |
| namesIndex.put(states[i].name, states[i]); |
| } |
| } |
| } |
| return (State) namesIndex.get(name); |
| } |
| private static void grabDefinitionFromComment(BufferedReader input) { |
| String line; |
| State current; |
| // use when the initializer is incomplete, hence needs to be reinitialized |
| // states = new State[stateMaxValue + 1]; |
| // use when the states field is final, with the appropriate size: |
| for (int i = 0; i <= stateMaxValue; i++) { |
| states[i] = null; |
| } |
| try { |
| while ((line = input.readLine()) != null && line.indexOf(definitionEndMarker) == -1) { |
| current = new State(line); |
| if (states[current.value] != null) { |
| throw new RuntimeException("duplicate state for index: " + current.value); |
| } |
| else { |
| states[current.value] = current; |
| } |
| } |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| for (int i = 0; i < stateMaxValue; i++) { |
| if (states[i] == null) { |
| states[i] = new State(i); |
| } |
| } |
| } |
| // PREMATURE may decide to remove |
| //private static void printAsInitializer() { |
| // int i, length; |
| // System.out.println(initializerStartMarker); |
| // for (i = 0, length = states.length; i < length; i++) { |
| // System.out.println(states[i].asInitializer()); |
| // } |
| // for (/* continue */; i <= stateMaxValue; i++) { |
| // System.out.println((new State(i)).asInitializer() + " CHECK"); |
| // } |
| // System.out.println(initializerEndMarker); |
| //} |
| // PREMATURE may decide to remove |
| //private static void printAsSourceComment() { |
| // int i, length; |
| // System.out.println("/*"); |
| // System.out.println(definitionStartMarker); |
| // for (i = 0, length = states.length; i < length; i++) { |
| // System.out.println(states[i].asSourceComment()); |
| // } |
| // for (/* continue */; i <= stateMaxValue; i++) { |
| // System.out.println((new State(i)).asSourceComment()); |
| // } |
| // System.out.println(definitionEndMarker); |
| // System.out.println("*/"); |
| //} |
| private final static String |
| definitionStartMarker = "// STATES " + CodeAnalysis.definitionStartMarker, |
| definitionEndMarker = "// STATES " + CodeAnalysis.definitionEndMarker, |
| initializerStartMarker = "// STATES " + CodeAnalysis.initializerStartMarker, |
| initializerEndMarker = "// STATES " + CodeAnalysis.initializerEndMarker; |
| static void reinitializeFromComment(BufferedReader input, BufferedWriter output) { |
| String line, tab = ""; |
| int cursor; |
| char c; |
| try { |
| while ((line = input.readLine()) != null) { |
| output.write(line); |
| output.write('\n'); |
| if ((cursor = line.indexOf(definitionStartMarker)) != -1) { |
| // check the line format |
| boolean reachedStart = true; |
| for (int i = 0; i < cursor; i++) { |
| if (!Character.isWhitespace(c = line.charAt(i))) { |
| reachedStart = false; |
| break; |
| } |
| else { |
| tab += c; |
| } |
| } |
| if (reachedStart) { |
| grabDefinitionFromComment(input); // consumes up to the END line |
| int i, length; |
| for (i = 0, length = states.length; i < length; i++) { |
| output.write(states[i].asSourceComment()); |
| output.write('\n'); |
| } |
| output.write(tab + definitionEndMarker + "\n"); |
| } |
| } |
| if ((cursor = line.indexOf(initializerStartMarker)) != -1) { |
| // check the line format |
| boolean reachedStart = true; |
| tab = ""; |
| for (int i = 0; i < cursor; i++) { |
| if (!Character.isWhitespace(c = line.charAt(i))) { |
| reachedStart = false; |
| break; |
| } |
| else { |
| tab += c; |
| } |
| } |
| if (reachedStart) { |
| while ((line = input.readLine()) != null && |
| line.indexOf(initializerEndMarker) == -1) { |
| // loop |
| } |
| int i, length; |
| for (i = 0, length = states.length; i < length; i++) { |
| output.write(states[i].asInitializer()); |
| output.write('\n'); |
| } |
| output.write(tab + initializerEndMarker + "\n"); |
| } |
| } |
| } |
| output.flush(); |
| namesIndex = null; |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| static Iterator symbolicStates() { |
| return new Iterator() { |
| int nextSymbolic = -1; |
| public boolean hasNext() { |
| if (this.nextSymbolic == -1) { |
| for (this.nextSymbolic = 0; this.nextSymbolic < states.length; this.nextSymbolic++) { |
| if (states[this.nextSymbolic].symbolic) { |
| break; |
| } |
| } |
| } else { |
| for (; this.nextSymbolic < states.length; this.nextSymbolic++) { |
| if (states[this.nextSymbolic].symbolic) { |
| break; |
| } |
| } |
| } |
| return this.nextSymbolic < states.length; |
| } |
| public Object next() { |
| State result = null; |
| if (this.nextSymbolic < states.length) { |
| result = states[this.nextSymbolic]; |
| this.nextSymbolic++; |
| } |
| return result; |
| } |
| public void remove() { |
| throw new RuntimeException("unimplemented"); |
| } |
| }; |
| } |
| public String toString() { |
| return this.name; |
| } |
| public boolean equals(Object other) { |
| return (other instanceof State) && ((State)other).value == this.value; |
| } |
| public int hashCode() { |
| return this.value; |
| } |
| } |
| |
| public NullReferenceImplTests(String name) { |
| super(name); |
| } |
| |
| // Tests tuning |
| // private static final boolean skipHighOrderBits = false; // define to true when tuning encoding |
| private static final int COMBINATION_TESTS_LOOP_NB = 1; // define to 10000s to measure performances |
| private static final boolean MEASURE_PERFORMANCES = COMBINATION_TESTS_LOOP_NB > 1; |
| |
| public static Test suite() { |
| // we do not want to run for 1.3, 1.4, 1.5 but once only |
| Class clazz = testClass(); |
| TestSuite all = new TestSuite(clazz.getName()); |
| List tests = buildTestsList(testClass()); |
| for (int i = 0, length = tests.size(); i < length; i++) { |
| all.addTest((Test) tests.get(i)); |
| } |
| return all; |
| } |
| |
| public static Class testClass() { |
| return NullReferenceImplTests.class; |
| } |
| |
| public void test2050_markAsComparedEqualToNonNull() { |
| int failures = NullReferenceImplTransformations.markAsComparedEqualToNonNull.test(); |
| assertTrue("nb of failures: " + failures, failures == 0); |
| } |
| |
| public void test2051_markAsComparedEqualToNull() { |
| int failures = NullReferenceImplTransformations.markAsComparedEqualToNull.test(); |
| assertTrue("nb of failures: " + failures, failures == 0); |
| } |
| |
| public void test2055_markAsDefinitelyNonNull() { |
| int failures = NullReferenceImplTransformations.markAsDefinitelyNonNull.test(); |
| assertTrue("nb of failures: " + failures, failures == 0); |
| } |
| |
| public void test2056_markAsDefinitelyNull() { |
| int failures = NullReferenceImplTransformations.markAsDefinitelyNull.test(); |
| assertTrue("nb of failures: " + failures, failures == 0); |
| } |
| |
| public void test2057_markAsDefinitelyUnknown() { |
| int failures = NullReferenceImplTransformations.markAsDefinitelyUnknown.test(); |
| assertTrue("nb of failures: " + failures, failures == 0); |
| } |
| |
| public void test2060_addInitializationsFrom() { |
| int failures = NullReferenceImplTransformations.addInitializationsFrom.test(); |
| assertTrue("nb of failures: " + failures, failures == 0); |
| } |
| |
| public void test2061_addPotentialInitializationsFrom() { |
| int failures = NullReferenceImplTransformations.addPotentialInitializationsFrom.test(); |
| assertTrue("nb of failures: " + failures, failures == 0); |
| } |
| |
| public void test2062_mergedWith() { |
| int failures = NullReferenceImplTransformations.mergedWith.test(); |
| assertTrue("nb of failures: " + failures, failures == 0); |
| } |
| |
| // PREMATURE rewrite from scratch |
| //public void _test2058_recode() { |
| // long [][][] testData = transitionsTablesData[recode]; |
| // int failures = 0; |
| // long start; |
| // if (combinationTestsloopsNb > 1) { |
| // start = System.currentTimeMillis(); |
| // } |
| // String header = "recode failures: "; |
| // for (int l = 0; l < combinationTestsloopsNb ; l++) { |
| // for (int i = 0; i < testData.length; i++) { |
| // UnconditionalFlowInfoTestHarness result; |
| // result = UnconditionalFlowInfoTestHarness. |
| // testUnconditionalFlowInfo(testData[i][0]); |
| // result.encode(); |
| // result.decode(); |
| // |
| // if (!result.testEquals(UnconditionalFlowInfoTestHarness. |
| // testUnconditionalFlowInfo(testData[i][0]))) { |
| // if (failures == 0) { |
| // System.out.println(header); |
| // } |
| // failures++; |
| // System.out.println("\t\t{" + result.testString() + |
| // "}, // instead of: " + testStringValueOf(testData[i][0])); |
| // } |
| // } |
| // } |
| // if (combinationTestsloopsNb > 1) { |
| // System.out.println("mergedWith\t\t\t" + combinationTestsloopsNb + "\t" + |
| // (System.currentTimeMillis() - start)); |
| // } |
| // for (int i = 0; i < testData.length; i++) { |
| // UnconditionalFlowInfoTestHarness result; |
| // result = UnconditionalFlowInfoTestHarness. |
| // testUnconditionalFlowInfo(testData[i][0], 64); |
| // result.encode(); |
| // result.decode(); |
| // |
| // if (!result.testEquals(UnconditionalFlowInfoTestHarness. |
| // testUnconditionalFlowInfo(testData[i][0], 64))) { |
| // if (failures == 0) { |
| // System.out.println(header); |
| // } |
| // failures++; |
| // System.out.println("\t\t{" + result.testString() + |
| // "}, // (64) - instead of: " + testStringValueOf(testData[i][0])); |
| // } |
| // } |
| // assertTrue("nb of failures: " + failures, failures == 0); |
| //} |
| |
| public void test2400_state_consistency() { |
| int failures = 0; |
| long start; |
| if (MEASURE_PERFORMANCES) { |
| start = System.currentTimeMillis(); |
| } |
| String header = "state consistency failures: "; |
| for (int l = 0; l < COMBINATION_TESTS_LOOP_NB ; l++) { |
| for (int i = 0; i < State.states.length; i++) { |
| if (State.states[i].symbolic) { |
| UnconditionalFlowInfoTestHarness |
| state = UnconditionalFlowInfoTestHarness. |
| testUnconditionalFlowInfo(State.states[i]); |
| boolean |
| isDefinitelyNonNull = state.isDefinitelyNonNull(TestLocalVariableBinding.local0), |
| isDefinitelyNull = state.isDefinitelyNull(TestLocalVariableBinding.local0), |
| isDefinitelyUnknown = state.isDefinitelyUnknown(TestLocalVariableBinding.local0), |
| isPotentiallyNonNull = state.isPotentiallyNonNull(TestLocalVariableBinding.local0), |
| isPotentiallyNull = state.isPotentiallyNull(TestLocalVariableBinding.local0), |
| isPotentiallyUnknown = state.isPotentiallyUnknown(TestLocalVariableBinding.local0), |
| isProtectedNonNull = state.isProtectedNonNull(TestLocalVariableBinding.local0), |
| isProtectedNull = state.isProtectedNull(TestLocalVariableBinding.local0), |
| cannotBeDefinitelyNullOrNonNull = state.cannotBeDefinitelyNullOrNonNull(TestLocalVariableBinding.local0), |
| cannotBeNull = state.cannotBeNull(TestLocalVariableBinding.local0), |
| canOnlyBeNull = state.canOnlyBeNull(TestLocalVariableBinding.local0); |
| if (isDefinitelyNonNull |
| && (isDefinitelyNull || isDefinitelyUnknown |
| || isPotentiallyNull |
| || isProtectedNull)) { |
| if (failures == 0) { |
| System.out.println(header); |
| } |
| failures++; |
| System.out.println("\t\tconsistency breakage for definitely non null state " + State.states[i].name); |
| } |
| if (isDefinitelyNull |
| && (isDefinitelyNonNull || isDefinitelyUnknown |
| || isPotentiallyUnknown || isProtectedNonNull)) { |
| if (failures == 0) { |
| System.out.println(header); |
| } |
| failures++; |
| System.out.println("\t\tconsistency breakage for definitely null state " + State.states[i].name); |
| } |
| if (isDefinitelyUnknown |
| && (isDefinitelyNonNull || isDefinitelyNull |
| || isPotentiallyNull || isProtectedNonNull |
| || isProtectedNull)) { |
| if (failures == 0) { |
| System.out.println(header); |
| } |
| failures++; |
| System.out.println("\t\tconsistency breakage for definitely unknown state " + State.states[i].name); |
| } |
| if (isProtectedNonNull && !isDefinitelyNonNull |
| || isProtectedNull && !isDefinitelyNull |
| || i > 0 // not start |
| && !State.states[i].name.equals("pot. non null") |
| && !(isDefinitelyNonNull || isDefinitelyNull |
| || isDefinitelyUnknown || isPotentiallyNull |
| || isPotentiallyUnknown || isProtectedNonNull |
| || isProtectedNull) |
| || cannotBeDefinitelyNullOrNonNull != |
| (isPotentiallyUnknown || |
| isPotentiallyNull && isPotentiallyNonNull) |
| || cannotBeNull != (isProtectedNonNull || |
| isDefinitelyNonNull) |
| || canOnlyBeNull != (isProtectedNull || |
| isDefinitelyNull)) { |
| if (failures == 0) { |
| System.out.println(header); |
| } |
| failures++; |
| System.out.println("\t\tconsistency breakage for " + State.states[i].name); |
| } |
| } |
| } |
| } |
| if (MEASURE_PERFORMANCES) { |
| System.out.println("mergedWith\t\t\t" + COMBINATION_TESTS_LOOP_NB + "\t" + |
| (System.currentTimeMillis() - start)); |
| } |
| for (int i = 0; i < State.states.length; i++) { |
| if (State.states[i].symbolic) { |
| UnconditionalFlowInfoTestHarness state; |
| state = UnconditionalFlowInfoTestHarness. |
| testUnconditionalFlowInfo(State.states[i], 64); |
| boolean |
| isDefinitelyNonNull = state.isDefinitelyNonNull(TestLocalVariableBinding.local64), |
| isDefinitelyNull = state.isDefinitelyNull(TestLocalVariableBinding.local64), |
| isDefinitelyUnknown = state.isDefinitelyUnknown(TestLocalVariableBinding.local64), |
| isPotentiallyNonNull = state.isPotentiallyNonNull(TestLocalVariableBinding.local64), |
| isPotentiallyNull = state.isPotentiallyNull(TestLocalVariableBinding.local64), |
| isPotentiallyUnknown = state.isPotentiallyUnknown(TestLocalVariableBinding.local64), |
| isProtectedNonNull = state.isProtectedNonNull(TestLocalVariableBinding.local64), |
| isProtectedNull = state.isProtectedNull(TestLocalVariableBinding.local64), |
| cannotBeDefinitelyNullOrNonNull = state.cannotBeDefinitelyNullOrNonNull(TestLocalVariableBinding.local64), |
| cannotBeNull = state.cannotBeNull(TestLocalVariableBinding.local64), |
| canOnlyBeNull = state.canOnlyBeNull(TestLocalVariableBinding.local64); |
| if (isDefinitelyNonNull |
| && (isDefinitelyNull || isDefinitelyUnknown |
| || isPotentiallyNull |
| || isProtectedNull)) { |
| if (failures == 0) { |
| System.out.println(header); |
| } |
| failures++; |
| System.out.println("\t\tconsistency breakage (64) for definitely non null state " + State.states[i].name); |
| } |
| if (isDefinitelyNull |
| && (isDefinitelyNonNull || isDefinitelyUnknown |
| || isPotentiallyUnknown || isProtectedNonNull)) { |
| if (failures == 0) { |
| System.out.println(header); |
| } |
| failures++; |
| System.out.println("\t\tconsistency breakage (64) for definitely null state " + State.states[i].name); |
| } |
| if (isDefinitelyUnknown |
| && (isDefinitelyNonNull || isDefinitelyNull |
| || isPotentiallyNull || isProtectedNonNull |
| || isProtectedNull)) { |
| if (failures == 0) { |
| System.out.println(header); |
| } |
| failures++; |
| System.out.println("\t\tconsistency breakage (64) for definitely unknown state " + State.states[i].name); |
| } |
| if (isProtectedNonNull && !isDefinitelyNonNull |
| || isProtectedNull && !isDefinitelyNull |
| || i > 0 // not start |
| && !State.states[i].name.equals("pot. non null") |
| && !(isDefinitelyNonNull || isDefinitelyNull |
| || isDefinitelyUnknown || isPotentiallyNull |
| || isPotentiallyUnknown || isProtectedNonNull |
| || isProtectedNull) |
| || cannotBeDefinitelyNullOrNonNull != |
| (isPotentiallyUnknown || |
| isPotentiallyNull && |
| isPotentiallyNonNull) |
| || cannotBeNull != (isProtectedNonNull || |
| isDefinitelyNonNull) |
| || canOnlyBeNull != (isProtectedNull || |
| isDefinitelyNull)) { |
| if (failures == 0) { |
| System.out.println(header); |
| } |
| failures++; |
| System.out.println("\t\tconsistency breakage (64) for " + State.states[i].name); |
| } |
| } |
| } |
| assertTrue("nb of failures: " + failures, failures == 0); |
| } |
| |
| public void test2500_addInitializationsFrom_for_definites() { |
| // when an added initialization is a def. something, it should |
| // affect the left hand term as the markAsDefinite* method would |
| // do |
| int failures = 0; |
| for (int i = 0; i < State.states.length; i++) { |
| if (State.states[i].symbolic) { |
| UnconditionalFlowInfoTestHarness source1, source2, result1, result2; |
| source1 = UnconditionalFlowInfoTestHarness. |
| testUnconditionalFlowInfo(State.states[i]); |
| for (int j = 0; j < State.states.length; j++) { |
| if (State.states[j].symbolic) { |
| source2 = UnconditionalFlowInfoTestHarness. |
| testUnconditionalFlowInfo(State.states[j]); |
| result1 = (UnconditionalFlowInfoTestHarness) source1.copy(); |
| result2 = (UnconditionalFlowInfoTestHarness) source1.copy(); |
| if (source2.isDefinitelyNonNull(TestLocalVariableBinding.local0)) { |
| if (! source2.isProtectedNonNull(TestLocalVariableBinding.local0)) { |
| result1.markAsDefinitelyNonNull(TestLocalVariableBinding.local0); |
| } else { |
| continue; |
| } |
| } |
| else if (source2.isDefinitelyNull(TestLocalVariableBinding.local0)) { |
| if (! source2.isProtectedNull(TestLocalVariableBinding.local0)) { |
| result1.markAsDefinitelyNull(TestLocalVariableBinding.local0); |
| } else { |
| continue; |
| } |
| } |
| else if (source2.isDefinitelyUnknown(TestLocalVariableBinding.local0)) { |
| result1.markAsDefinitelyUnknown(TestLocalVariableBinding.local0); |
| } |
| else if (source2.nullBit1 != 0) { |
| if (failures == 0) { |
| System.out.println("addInitializationsFrom_for_definites failures: "); //$NON-NLS-1$ |
| } |
| failures++; |
| System.out.println("\t\t" + State.states[j].name + |
| " should answer true to at least one isDefinite* query"); |
| // PREMATURE move to specific queries test case |
| } |
| else { |
| continue; |
| } |
| result2.addInitializationsFrom(source2); |
| if (!result1.testEquals(result2)) { |
| if (failures == 0) { |
| System.out.println("addInitializationsFrom_for_definites failures: "); //$NON-NLS-1$ |
| } |
| failures++; |
| System.out.println("\t\t" + State.states[i].name + |
| " + " + State.states[j].name + |
| " => " + result2.asState().name + |
| " instead of: " + result1.asState().name); |
| } |
| } |
| } |
| } |
| } |
| assertTrue("nb of failures: " + failures, failures == 0); |
| } |
| |
| // Use for coverage tests only. Needs specific instrumentation of code, |
| // that is controled by UnconditionalFlowInfo#coverageTestFlag. |
| // Note: coverage tests tend to fill the console with messages, and the |
| // instrumented code is slower, so never release code with active |
| // coverage tests. |
| private static int coveragePointsNb = 45; |
| |
| // PREMATURE reactivate coverage tests |
| // Coverage by state transition tables methods. |
| public void test2998_coverage() { |
| if (UnconditionalFlowInfo.COVERAGE_TEST_FLAG) { |
| // sanity check: need to be sure that the tests execute properly when not |
| // trying to check coverage |
| UnconditionalFlowInfo.CoverageTestId = 0; |
| test0053_array(); |
| test0070_type_reference(); |
| test2050_markAsComparedEqualToNonNull(); |
| test2051_markAsComparedEqualToNull(); |
| test2055_markAsDefinitelyNonNull(); |
| test2056_markAsDefinitelyNull(); |
| test2057_markAsDefinitelyUnknown(); |
| test2060_addInitializationsFrom(); |
| test2061_addPotentialInitializationsFrom(); |
| test2062_mergedWith(); |
| testBug292478(); |
| testBug292478c(); |
| test0331_if_else_nested(); |
| testBug325755b(); |
| testBug292478g(); |
| // coverage check |
| int failuresNb = 0; |
| for (int i = 1; i <= coveragePointsNb; i++) { |
| if (i == 11 || i == 12 || i == 14) { |
| continue; |
| // these can only be reached via a direct call to addPotentialNullInfoFrom, |
| // which is not implemented in low level tests - all those go through |
| // addPotentialInitsFrom |
| } |
| try { |
| UnconditionalFlowInfo.CoverageTestId = i; |
| test0053_array(); |
| test0070_type_reference(); |
| test2050_markAsComparedEqualToNonNull(); |
| test2051_markAsComparedEqualToNull(); |
| test2055_markAsDefinitelyNonNull(); |
| test2056_markAsDefinitelyNull(); |
| test2057_markAsDefinitelyUnknown(); |
| test2060_addInitializationsFrom(); |
| test2061_addPotentialInitializationsFrom(); |
| test2062_mergedWith(); |
| testBug292478(); |
| testBug292478c(); |
| test0331_if_else_nested(); |
| testBug325755b(); |
| testBug292478g(); |
| } |
| catch (AssertionFailedError e) { |
| continue; |
| } |
| catch (AssertionFailedException e) { |
| continue; |
| } |
| failuresNb++; |
| System.out.println("Missing coverage point: " + i); |
| } |
| UnconditionalFlowInfo.CoverageTestId = 0; // reset for other tests |
| assertEquals(failuresNb + " missing coverage point(s)", failuresNb, 0); |
| } |
| } |
| |
| // Coverage by code samples. |
| public void test2999_coverage() { |
| if (UnconditionalFlowInfo.COVERAGE_TEST_FLAG) { |
| // sanity check: need to be sure that the tests execute properly when not |
| // trying to check coverage |
| UnconditionalFlowInfo.CoverageTestId = 0; |
| test0001_simple_local(); |
| test0053_array(); |
| test0070_type_reference(); |
| test0327_if_else(); |
| test0401_while(); |
| test0420_while(); |
| test0509_try_finally_embedded(); |
| test2000_flow_info(); |
| test2004_flow_info(); |
| test2008_flow_info(); |
| test2011_flow_info(); |
| test2013_flow_info(); |
| test2018_flow_info(); |
| test2019_flow_info(); |
| test2020_flow_info(); |
| // coverage check |
| int failuresNb = 0; |
| for (int i = 1; i <= coveragePointsNb; i++) { |
| if (i < 3 |
| || 4 < i && i < 11 |
| || 11 < i && i < 16 |
| || 16 < i && i < 20 |
| || i == 21 |
| || 23 < i && i < 27 |
| || 29 < i && i < 33 |
| || 36 < i) { // TODO (maxime) complete coverage tests |
| continue; |
| } |
| try { |
| UnconditionalFlowInfo.CoverageTestId = i; |
| test0001_simple_local(); |
| test0053_array(); |
| test0070_type_reference(); |
| test0327_if_else(); |
| test0401_while(); |
| test0420_while(); |
| test0509_try_finally_embedded(); |
| test2000_flow_info(); |
| test2004_flow_info(); |
| test2008_flow_info(); |
| test2011_flow_info(); |
| test2013_flow_info(); |
| test2018_flow_info(); |
| test2019_flow_info(); |
| test2020_flow_info(); |
| } |
| catch (AssertionFailedError e) { |
| continue; |
| } |
| catch (AssertionFailedException e) { |
| continue; |
| } |
| failuresNb++; |
| System.out.println("Missing coverage point: " + i); |
| } |
| UnconditionalFlowInfo.CoverageTestId = 0; // reset for other tests |
| assertEquals(failuresNb + " missing coverage point(s)", failuresNb, 0); |
| } |
| } |
| |
| // only works for info coded on bit 0 - least significant |
| String testCodedValueOf(long[] data) { |
| int length; |
| StringBuffer result = new StringBuffer(length = data.length); |
| for (int i = 0; i < length; i++) { |
| result.append(data[i] == 0 ? '0' : '1'); |
| } |
| return result.toString(); |
| } |
| |
| static String testStringValueOf(long[] data) { |
| int length; |
| StringBuffer result = new StringBuffer((length = data.length) * 2 + 1); |
| result.append('{'); |
| for (int i = 0; i < length; i++) { |
| if (i > 0) { |
| result.append(','); |
| } |
| result.append(data[i]); |
| } |
| result.append('}'); |
| return result.toString(); |
| } |
| } |
| |
| /** |
| * A specific extension of LocalVariableBinding suitable for flow info |
| * manipulation at an implementation level. |
| */ |
| class TestLocalVariableBinding extends LocalVariableBinding { |
| static class TestTypeBinding extends TypeBinding { |
| public TestTypeBinding() { |
| this.tagBits = 0L; |
| } |
| public char[] constantPoolName() { |
| return null; |
| } |
| public PackageBinding getPackage() { |
| return null; |
| } |
| public boolean isCompatibleWith(TypeBinding right, Scope captureScope) { |
| return false; |
| } |
| public char[] qualifiedSourceName() { |
| return null; |
| } |
| public char[] sourceName() { |
| return null; |
| } |
| public char[] readableName() { |
| return null; |
| } |
| } |
| final static TypeBinding testTypeBinding = new TestTypeBinding(); |
| final static char [] testName = {'t', 'e', 's', 't'}; |
| TestLocalVariableBinding(int id) { |
| super(testName, testTypeBinding, 0, false); |
| this.id = id; |
| } |
| public Constant constant() { |
| return Constant.NotAConstant; |
| } |
| static final TestLocalVariableBinding |
| local0 = new TestLocalVariableBinding(0), |
| local64 = new TestLocalVariableBinding(64), |
| local128 = new TestLocalVariableBinding(128); |
| } |
| |
| /** |
| * A class meant to augment |
| * @link{org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo} with |
| * capabilities in the test domain. It especially provides factories to build |
| * fake flow info instances for use in state transitions validation. |
| */ |
| /* |
| * Moreover, this class defines the implementation of key operations for the |
| * benefit of itself and NullInfoRegistryTestHarness. Given the fact that the |
| * latter could not extend UnconditionalFlowInfoTestHarness and |
| * NullInfoRegistry, the code is factorized into static methods. |
| */ |
| class UnconditionalFlowInfoTestHarness extends UnconditionalFlowInfo { |
| int testPosition; |
| // Interface |
| /** |
| * Return the state represented by this. |
| * @return the state represented by this |
| */ |
| NullReferenceImplTests.State asState() { |
| return asState(this, 0); |
| } |
| |
| /** |
| * Return the state represented by this for a variable encoded at a given position. |
| * @param position - int the position of the considered variable |
| * @return the state represented by this for a variable encoded at a given position |
| */ |
| NullReferenceImplTests.State asState(int position) { |
| return asState(this, position); |
| } |
| |
| public FlowInfo copy() { |
| UnconditionalFlowInfoTestHarness copy = |
| new UnconditionalFlowInfoTestHarness(); |
| copy.testPosition = this.testPosition; |
| copy(this, copy); |
| return copy; |
| } |
| |
| public void markAsDefinitelyNonNull(LocalVariableBinding local) { |
| grow(local.id + this.maxFieldCount); |
| super.markAsDefinitelyNonNull(local); |
| } |
| |
| public void markAsDefinitelyNull(LocalVariableBinding local) { |
| grow(local.id + this.maxFieldCount); |
| super.markAsDefinitelyNull(local); |
| } |
| |
| public void markAsDefinitelyUnknown(LocalVariableBinding local) { |
| grow(local.id + this.maxFieldCount); |
| super.markAsDefinitelyUnknown(local); |
| } |
| |
| /** |
| * Return a fake unconditional flow info which bit fields represent the given |
| * null bits for a local variable of id 0 within a class that would have no |
| * field. |
| * @param nullBits the bits that must be set, given in the same order as the |
| * nullAssignment* fields in UnconditionalFlowInfo definition; use 0 |
| * for a bit that is not set, 1 else |
| * @return a fake unconditional flow info which bit fields represent the |
| * null bits given in parameter |
| */ |
| public static UnconditionalFlowInfoTestHarness testUnconditionalFlowInfo( |
| long [] nullBits) { |
| return testUnconditionalFlowInfo(nullBits, 0); |
| } |
| |
| /** |
| * Return a fake unconditional flow info which bit fields represent the given |
| * null bits for a local variable of id position within a class that would have |
| * no field. |
| * @param nullBits the bits that must be set, given in the same order as the |
| * nullAssignment* fields in UnconditionalFlowInfo definition; use 0 |
| * for a bit that is not set, 1 else |
| * @param position the position of the variable within the bit fields; use |
| * various values to test different parts of the bit fields, within |
| * or beyond BitCacheSize |
| * @return a fake unconditional flow info which bit fields represent the |
| * null bits given in parameter |
| */ |
| public static UnconditionalFlowInfoTestHarness testUnconditionalFlowInfo( |
| long [] nullBits, int position) { |
| UnconditionalFlowInfoTestHarness result = |
| new UnconditionalFlowInfoTestHarness(); |
| result.testPosition = position; |
| init(result, nullBits, position); |
| return result; |
| } |
| |
| /** |
| * Return a fake unconditional flow info which bit fields represent the given |
| * state for a local variable of id 0 within a class that would have |
| * no field. |
| * @param state - State the desired state for the variable |
| * @return a fake unconditional flow info which bit fields represent the |
| * state given in parameter |
| */ |
| public static UnconditionalFlowInfoTestHarness testUnconditionalFlowInfo(NullReferenceImplTests.State state) { |
| return testUnconditionalFlowInfo(state, 0); |
| } |
| |
| /** |
| * Return a fake unconditional flow info which bit fields represent the given |
| * state for a local variable of id position within a class that would have |
| * no field. |
| * @param state - State the desired state for the variable |
| * @param position the position of the variable within the bit fields; use |
| * various values to test different parts of the bit fields, within |
| * or beyond BitCacheSize |
| * @return a fake unconditional flow info which bit fields represent the |
| * state given in parameter |
| */ |
| public static UnconditionalFlowInfoTestHarness testUnconditionalFlowInfo( |
| NullReferenceImplTests.State state, int position) { |
| UnconditionalFlowInfoTestHarness result = |
| new UnconditionalFlowInfoTestHarness(); |
| long[] nullBits = state.asLongArray(); |
| result.testPosition = position; |
| init(result, nullBits, position); |
| return result; |
| } |
| |
| /** |
| * Return true iff this flow info can be considered as equal to the one passed |
| * in parameter. |
| * @param other the flow info to compare to |
| * @return true iff this flow info compares equal to other |
| */ |
| public boolean testEquals(UnconditionalFlowInfo other) { |
| return testEquals(this, other); |
| } |
| |
| /** |
| * Return true iff this flow info can be considered as equal to the one passed |
| * in parameter in respect with a single local variable which id would be |
| * position in a class with no field. |
| * @param other the flow info to compare to |
| * @param position the position of the local to consider |
| * @return true iff this flow info compares equal to other for a given local |
| */ |
| public boolean testEquals(UnconditionalFlowInfo other, int position) { |
| return testEquals(this, other, position); |
| } |
| |
| /** |
| * Return a string suitable for use as a representation of this flow info |
| * within test series. |
| * @return a string suitable for use as a representation of this flow info |
| */ |
| public String testString() { |
| if (this == DEAD_END) { |
| return "FlowInfo.DEAD_END"; //$NON-NLS-1$ |
| } |
| return testString(this, this.testPosition); |
| } |
| |
| /** |
| * Return a string suitable for use as a representation of this flow info |
| * within test series. |
| * @param position a position to consider instead of this flow info default |
| * test position |
| * @return a string suitable for use as a representation of this flow info |
| */ |
| public String testString(int position) { |
| return testString(this, position); |
| } |
| |
| // Factorized implementation |
| static NullReferenceImplTests.State asState(UnconditionalFlowInfo zis, int position) { |
| if ((zis.tagBits & NULL_FLAG_MASK) == 0) { |
| return NullReferenceImplTests.State.start; |
| } |
| if (position < BitCacheSize) { |
| return NullReferenceImplTests.State.fromLongValues( |
| (zis.nullBit1 >> position) & 1, |
| (zis.nullBit2 >> position) & 1, |
| (zis.nullBit3 >> position) & 1, |
| (zis.nullBit4 >> position) & 1, |
| 0, |
| 0); |
| } |
| else { |
| int vectorIndex = (position / BitCacheSize) - 1; |
| position %= BitCacheSize; |
| if (vectorIndex >= zis.extra[2].length) { |
| return NullReferenceImplTests.State.start; |
| } |
| return NullReferenceImplTests.State.fromLongValues( |
| (zis.extra[2][vectorIndex] >> position) & 1, |
| (zis.extra[3][vectorIndex] >> position) & 1, |
| (zis.extra[4][vectorIndex] >> position) & 1, |
| (zis.extra[5][vectorIndex] >> position) & 1, |
| 0 //(zis.extra[6][vectorIndex] >> position) & 1, |
| , 0 //(zis.extra[7][vectorIndex] >> position) & 1 |
| ); |
| } |
| } |
| |
| static void copy(UnconditionalFlowInfo source, UnconditionalFlowInfo target) { |
| target.definiteInits = source.definiteInits; |
| target.potentialInits = source.potentialInits; |
| boolean hasNullInfo = (source.tagBits & NULL_FLAG_MASK) != 0; |
| if (hasNullInfo) { |
| target.nullBit1 = source.nullBit1; |
| target.nullBit2 = source.nullBit2; |
| target.nullBit3 = source.nullBit3; |
| target.nullBit4 = source.nullBit4; |
| } |
| target.iNBit = source.iNBit; |
| target.iNNBit = source.iNNBit; |
| target.tagBits = source.tagBits; |
| target.maxFieldCount = source.maxFieldCount; |
| if (source.extra != null) { |
| int length; |
| target.extra = new long[extraLength][]; |
| System.arraycopy(source.extra[0], 0, |
| (target.extra[0] = new long[length = source.extra[0].length]), 0, length); |
| System.arraycopy(source.extra[1], 0, |
| (target.extra[1] = new long[length]), 0, length); |
| if (hasNullInfo) { |
| for (int j = 0; j < extraLength; j++) { |
| System.arraycopy(source.extra[j], 0, |
| (target.extra[j] = new long[length]), 0, length); |
| } |
| } |
| else { |
| for (int j = 0; j < extraLength; j++) { |
| target.extra[j] = new long[length]; |
| } |
| } |
| } |
| } |
| |
| public void grow(int position) { |
| int vectorIndex = ((position) / BitCacheSize) - 1; |
| int length = vectorIndex + 1, oldLength; |
| if (this.extra == null) { |
| this.extra = new long[extraLength][]; |
| for (int j = 0; j < extraLength; j++) { |
| this.extra[j] = new long[length]; |
| } |
| } else if (length > (oldLength = this.extra[2].length)) { |
| for (int j = 0; j < extraLength; j++) { |
| System.arraycopy(this.extra[j], 0, |
| this.extra[j] = new long[length], 0, oldLength); |
| } |
| } |
| } |
| |
| static void init(UnconditionalFlowInfo zis, long [] nullBits, int position) { |
| if (position < BitCacheSize) { |
| zis.nullBit1 = nullBits[0] << position; |
| zis.nullBit2 = nullBits[1] << position; |
| zis.nullBit3 = nullBits[2] << position; |
| zis.nullBit4 = nullBits[3] << position; |
| } |
| else { |
| int vectorIndex = (position / BitCacheSize) - 1, |
| length = vectorIndex + 1; |
| position %= BitCacheSize; |
| zis.extra = new long[extraLength][]; |
| zis.extra[0] = new long[length]; |
| zis.extra[1] = new long[length]; |
| for (int j = 2; j < extraLength; j++) { |
| zis.extra[j] = new long[length]; |
| zis.extra[j][vectorIndex] = nullBits[j - 2] << position; |
| } |
| // FIXME: while IN,INN are not included in nullBits: |
| Arrays.fill(zis.extra[UnconditionalFlowInfo.IN], -1L); |
| Arrays.fill(zis.extra[UnconditionalFlowInfo.INN], -1L); |
| } |
| zis.iNBit = -1L; // FIXME: nullBits[4] << position; |
| zis.iNNBit = -1L; // FIXME: nullBits[5] << position; |
| if (nullBits[0] != 0 || nullBits[1] != 0 |
| || nullBits[2] != 0 || nullBits[3] != 0 |
| || nullBits[4] != 0 || nullBits[5] != 0) { |
| // cascade better than nullBits[0] | nullBits[1] | nullBits[2] | nullBits[3] |
| // by 10%+ |
| // TODO (maxime) run stats to determine which is the better order |
| zis.tagBits |= NULL_FLAG_MASK; |
| } |
| zis.maxFieldCount = 0; |
| } |
| |
| static boolean testEquals(UnconditionalFlowInfo zis, UnconditionalFlowInfo other) { |
| if (zis.tagBits != other.tagBits) { |
| return false; |
| } |
| if (zis.nullBit1 != other.nullBit1 |
| || zis.nullBit2 != other.nullBit2 |
| || zis.nullBit3 != other.nullBit3 |
| || zis.nullBit4 != other.nullBit4 |
| /*|| zis.iNBit != other.iNBit // FIXME: include these bits in comparison? |
| || zis.iNNBit != other.iNNBit */) { |
| return false; |
| } |
| int left = zis.extra == null ? 0 : zis.extra[2].length, |
| right = other.extra == null ? 0 : other.extra[2].length, |
| both = 0, i; |
| if (left > right) { |
| both = right; |
| } |
| else { |
| both = left; |
| } |
| for (i = 0; i < both ; i++) { |
| for (int j = 2; j < extraLength; j++) { |
| if (zis.extra[j][i] != |
| other.extra[j][i]) { |
| return false; |
| } |
| } |
| } |
| for (; i < left; i++) { |
| for (int j = 2; j < extraLength; j++) { |
| if (zis.extra[j][i] != 0) { |
| return false; |
| } |
| } |
| } |
| for (; i < right; i++) { |
| for (int j = 2; j < extraLength; j++) { |
| if (other.extra[j][i] != 0) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| static boolean testEquals(UnconditionalFlowInfo zis, UnconditionalFlowInfo other, |
| int position) { |
| int vectorIndex = position / BitCacheSize - 1; |
| if ((zis.tagBits & other.tagBits & NULL_FLAG_MASK) == 0) { |
| return true; |
| } |
| long mask; |
| if (vectorIndex < 0) { |
| return ((zis.nullBit1 & (mask = (1L << position))) ^ |
| (other.nullBit1 & mask)) == 0 && |
| ((zis.nullBit2 & mask) ^ |
| (other.nullBit2 & mask)) == 0 && |
| ((zis.nullBit3 & mask) ^ |
| (other.nullBit3 & mask)) == 0 && |
| ((zis.nullBit4 & mask) ^ |
| (other.nullBit4 & mask)) == 0 /* && // FIXME: include these bits in comparison? |
| ((zis.iNBit & mask) ^ |
| (other.iNBit & mask)) == 0 && |
| ((zis.iNNBit & mask) ^ |
| (other.iNNBit & mask)) == 0 */; |
| } |
| else { |
| int left = zis.extra == null ? |
| 0 : |
| zis.extra[0].length; |
| int right = other.extra == null ? |
| 0 : |
| other.extra[0].length; |
| int both = left < right ? left : right; |
| if (vectorIndex < both) { |
| mask = (1L << (position % BitCacheSize)); |
| for (int j = 2; j < extraLength; j++) { |
| if (((zis.extra[j][vectorIndex] & mask) |
| ^ (other.extra[j][vectorIndex] & mask)) != 0) { |
| return false; |
| } |
| } |
| return true; |
| } |
| if (vectorIndex < left) { |
| return ((zis.extra[2][vectorIndex] | |
| zis.extra[3][vectorIndex] | |
| zis.extra[4][vectorIndex] | |
| zis.extra[5][vectorIndex] | |
| zis.extra[6][vectorIndex] | |
| zis.extra[7][vectorIndex]) & |
| (1L << (position % BitCacheSize))) == 0; |
| } |
| return ((other.extra[2][vectorIndex] | |
| other.extra[3][vectorIndex] | |
| other.extra[4][vectorIndex] | |
| other.extra[5][vectorIndex] | |
| other.extra[6][vectorIndex] | |
| other.extra[7][vectorIndex]) & |
| (1L << (position % BitCacheSize))) == 0; |
| } |
| } |
| |
| static String testString(UnconditionalFlowInfo zis, int position) { |
| if (zis == DEAD_END) { |
| return "FlowInfo.DEAD_END"; //$NON-NLS-1$ |
| } |
| if (position < BitCacheSize) { |
| return "{" + (zis.nullBit1 >> position) //$NON-NLS-1$ |
| + "," + (zis.nullBit2 >> position) //$NON-NLS-1$ |
| + "," + (zis.nullBit3 >> position) //$NON-NLS-1$ |
| + "," + (zis.nullBit4 >> position) //$NON-NLS-1$ |
| // + "," + (zis.iNBit >> position) //$NON-NLS-1$ |
| // + "," + (zis.iNNBit >> position) //$NON-NLS-1$ |
| + "}"; //$NON-NLS-1$ |
| } |
| else { |
| int vectorIndex = position / BitCacheSize - 1, |
| shift = position % BitCacheSize; |
| return "{" + (zis.extra[2][vectorIndex] //$NON-NLS-1$ |
| >> shift) |
| + "," + (zis.extra[3][vectorIndex] //$NON-NLS-1$ |
| >> shift) |
| + "," + (zis.extra[4][vectorIndex] //$NON-NLS-1$ |
| >> shift) |
| + "," + (zis.extra[5][vectorIndex] //$NON-NLS-1$ |
| >> shift) |
| // + "," + (zis.extra[6][vectorIndex] //$NON-NLS-1$ |
| // >> shift) |
| // + "," + (zis.extra[7][vectorIndex] //$NON-NLS-1$ |
| // >> shift) |
| + "}"; //$NON-NLS-1$ |
| } |
| } |
| } |
| interface CodeAnalysis { |
| public static final String |
| definitionStartMarker = "DEFINITION START", |
| definitionEndMarker = "DEFINITION END", |
| initializerStartMarker = "INITIALIZER START", |
| initializerEndMarker = "INITIALIZER END"; |
| } |
| @SuppressWarnings({ "unchecked", "rawtypes" }) |
| class TransitiveClosureHolder { |
| static class Element { |
| NullReferenceImplTests.State value; |
| boolean alreadyKnown; |
| Element(NullReferenceImplTests.State value) { |
| if (value == null) { |
| throw new IllegalArgumentException("not a valid element"); |
| } |
| this.value = value; |
| } |
| } |
| Map elements = new TreeMap(); |
| public TransitiveClosureHolder() { |
| Element start = new Element(NullReferenceImplTests.State.start); |
| this.elements.put(start.value, start); |
| } |
| void add(NullReferenceImplTests.State value) { |
| if (value == null) { |
| throw new IllegalArgumentException("not a valid state"); |
| } |
| if (! this.elements.containsKey(value)) { |
| this.elements.put(value, new Element(value)); |
| } |
| } |
| void add(NullReferenceImplTests.State[] values) { |
| if (values == null) { |
| throw new IllegalArgumentException("not a valid states set"); |
| } |
| for (int i = 0, length = values.length; i < length; i++) { |
| add(values[i]); |
| } |
| } |
| NullReferenceImplTests.State[] asArray() { |
| int length; |
| NullReferenceImplTests.State[] result = new NullReferenceImplTests.State[length = this.elements.size()]; |
| Iterator elementsIterator = this.elements.keySet().iterator(); |
| for (int j = 0; j < length; j++) { |
| result[j] = (NullReferenceImplTests.State) elementsIterator.next(); |
| } |
| return result; |
| } |
| NullReferenceImplTests.State[] notAlreadyKnowns() { |
| List resultAccumulator = new ArrayList(this.elements.size()); |
| Iterator i = this.elements.values().iterator(); |
| Element current; |
| while (i.hasNext()) { |
| if (! (current = (Element) i.next()).alreadyKnown) { |
| resultAccumulator.add(current.value); |
| } |
| } |
| int length; |
| NullReferenceImplTests.State[] result = new NullReferenceImplTests.State[length = resultAccumulator.size()]; |
| for (int j = 0; j < length; j++) { |
| result[j] = (NullReferenceImplTests.State) resultAccumulator.get(j); |
| } |
| return result; |
| } |
| void markAllAsAlreadyKnown() { |
| Iterator i = this.elements.values().iterator(); |
| while (i.hasNext()) { |
| ((Element) i.next()).alreadyKnown = true; |
| } |
| } |
| public String toString() { |
| StringBuffer output = new StringBuffer(); |
| output.append("Transitive closure:\n"); |
| SortedMap sorted = new TreeMap(this.elements); |
| Iterator i = sorted.keySet().iterator(); |
| while (i.hasNext()) { |
| output.append(i.next().toString()); |
| output.append('\n'); |
| } |
| return output.toString(); |
| } |
| } |
| |
| // PREMATURE segregate pure tooling into a separate project, keep tests only here |
| /** |
| * The Generator class is meant to generate the tabular data needed by the |
| * flow information implementation level tests. While the tests should ensure |
| * non regression by leveraging their initialization tables only, any change |
| * into the flow information logic or encoding is due to yield considerable |
| * changes into the literal values sets of the initializers themselves. |
| * Tooling the production of those literals buys us flexibility. |
| * {@link #printHelp printHelp} for details. |
| */ |
| @SuppressWarnings({ "unchecked", "rawtypes" }) |
| class Generator { |
| static NullReferenceImplTests.State[] computeTransitiveClosure() { |
| TransitiveClosureHolder transitiveClosure = new TransitiveClosureHolder(); |
| NullReferenceImplTests.State[] unknowns; |
| unknowns = transitiveClosure.notAlreadyKnowns(); |
| while (unknowns.length != 0) { |
| transitiveClosure.markAllAsAlreadyKnown(); |
| for (int i = 0, length = NullReferenceImplTransformations.transformations.length; i < length; i ++) { |
| transitiveClosure.add( |
| NullReferenceImplTransformations.transformations[i]. |
| computeOutputs(transitiveClosure.asArray())); |
| } |
| unknowns = transitiveClosure.notAlreadyKnowns(); |
| } |
| return transitiveClosure.asArray(); |
| } |
| public static void main(String[] args) { |
| if (args.length == 0) { |
| printHelp(false); |
| System.exit(1); |
| } |
| switch (args.length) { |
| case 1: |
| if (args[0].equals("--help")) { |
| printHelp(true); |
| System.exit(0); |
| } |
| else { |
| printHelp(false); |
| System.exit(1); |
| } |
| break; |
| case 2: |
| if (args[0].equals("--printTruthTables")) { |
| File outputDir = new File(args[1]); |
| if (outputDir.isDirectory()) { |
| for (int i = 0, length = NullReferenceImplTransformations.transformations.length; i < length; i++) { |
| NullReferenceImplTransformations.transformations[i].printTruthTables(outputDir); |
| } |
| } |
| else { |
| // PREMATURE error handling |
| } |
| System.exit(0); |
| } |
| else { |
| printHelp(false); |
| System.exit(1); |
| } |
| break; |
| case 3: |
| if (args[0].equals("--reinitializeFromComputedValues")) { |
| reinitializeFromComputedValues(args[1], args[2]); |
| System.out.println("Generator generated new file into " + args[2]); |
| System.exit(0); |
| } |
| //$FALL-THROUGH$ |
| case 5: |
| if (args[0].equals("--reinitializeFromComments")) { |
| reinitializeFromComments(args[1], args[2], args[3], args[4]); |
| System.out.println("Generator generated new files into " + args[2] |
| + " and " + args[4]); |
| System.exit(0); |
| } |
| //$FALL-THROUGH$ |
| default: |
| printHelp(false); |
| System.exit(1); |
| } |
| } |
| |
| private static void reinitializeFromComments( |
| String statesSource, String statesTarget, |
| String transformationsSource, String transformationsTarget) { |
| if (statesSource.equals(transformationsSource) || |
| statesTarget.equals(transformationsTarget)) { |
| throw new RuntimeException(); |
| } |
| try { |
| BufferedReader in; |
| BufferedWriter out; |
| NullReferenceImplTests.State.reinitializeFromComment( |
| in = new BufferedReader( |
| new FileReader(statesSource)), |
| out = new BufferedWriter(new FileWriter(statesTarget))); |
| in.close(); |
| out.close(); |
| File[] tempFiles = new File[2]; |
| tempFiles[0] = File.createTempFile("generator", "java"); |
| tempFiles[1] = File.createTempFile("generator", "java"); |
| NullReferenceImplTransformations.transformations[0].reinitializeFromComments( |
| in = new BufferedReader( |
| new FileReader(transformationsSource)), |
| out = new BufferedWriter(new FileWriter(tempFiles[0]))); |
| in.close(); |
| out.close(); |
| int i, length; |
| for (i = 1, length = NullReferenceImplTransformations.transformations.length - 1; i < length; i++) { |
| NullReferenceImplTransformations.transformations[i].reinitializeFromComments( |
| in = new BufferedReader( |
| new FileReader(tempFiles[(i + 1) % 2])), |
| out = new BufferedWriter(new FileWriter(tempFiles[i % 2]))); |
| in.close(); |
| out.close(); |
| } |
| NullReferenceImplTransformations.transformations[i].reinitializeFromComments( |
| in = new BufferedReader( |
| new FileReader(tempFiles[(i + 1) % 2])), |
| out = new BufferedWriter(new FileWriter(transformationsTarget))); |
| in.close(); |
| out.close(); |
| } catch (Throwable t) { |
| System.err.println("Generator error:"); |
| t.printStackTrace(System.err); |
| System.exit(2); |
| } |
| } |
| |
| private static void reinitializeFromComputedValues(String source, String target) { |
| for (int i = 0, length = NullReferenceImplTransformations.transformations.length; |
| i < length; i++) { |
| NullReferenceImplTransformations.transformations[i].hydrate(); |
| } |
| NullReferenceImplTests.State[] transitiveClosure = computeTransitiveClosure(); // need for initialization? |
| transitiveClosure = addSymbolicStates(transitiveClosure); // don't rely on reachibility alone, since we don't cover all operations in these tests. |
| Arrays.sort(transitiveClosure, new Comparator() { |
| public int compare(Object o1, Object o2) { |
| return Integer.valueOf(((State)o1).value).compareTo(Integer.valueOf(((State)o2).value)); |
| } |
| }); |
| try { |
| BufferedReader in; |
| BufferedWriter out; |
| File[] tempFiles = new File[2]; |
| tempFiles[0] = File.createTempFile("generator", "java"); |
| tempFiles[1] = File.createTempFile("generator", "java"); |
| NullReferenceImplTransformations.transformations[0].reinitializeFromComputedValues( |
| in = new BufferedReader( |
| new FileReader(source)), |
| out = new BufferedWriter(new FileWriter(tempFiles[0])), |
| transitiveClosure); |
| in.close(); |
| out.close(); |
| int i, length; |
| for (i = 1, length = NullReferenceImplTransformations.transformations.length - 1; i < length; i++) { |
| NullReferenceImplTransformations.transformations[i].reinitializeFromComputedValues( |
| in = new BufferedReader( |
| new FileReader(tempFiles[(i + 1) % 2])), |
| out = new BufferedWriter(new FileWriter(tempFiles[i % 2])), |
| transitiveClosure); |
| in.close(); |
| out.close(); |
| } |
| NullReferenceImplTransformations.transformations[i].reinitializeFromComputedValues( |
| in = new BufferedReader( |
| new FileReader(tempFiles[(i + 1) % 2])), |
| out = new BufferedWriter(new FileWriter(target)), |
| transitiveClosure); |
| in.close(); |
| out.close(); |
| } catch (Throwable t) { |
| System.err.println("Generator error:"); |
| t.printStackTrace(System.err); |
| System.exit(2); |
| } |
| } |
| private static State[] addSymbolicStates(State[] transitiveClosure) { |
| Set allStates = new HashSet(); |
| for (int i = 0; i < transitiveClosure.length; i++) |
| allStates.add(transitiveClosure[i]); |
| for (int i=0; i < State.statesNb; i++) |
| if (State.states[i].symbolic) |
| allStates.add(State.states[i]); |
| return (State[]) allStates.toArray(new State[allStates.size()]); |
| } |
| |
| private static void printHelp(boolean longText) { |
| if (longText) { |
| System.out.println( |
| "Generator use cases\n" + |
| " - when a brand new logic is experimented for the transitions, the best\n" + |
| " way to go is to write explicit (inefficient) transformation code within\n" + |
| " UnconditionalFlowInfo, then generate the literal initializers from\n" + |
| " there; use the command\n" + |
| " --reinitializeFromComputedValues <source file> <target file>\n" + |
| " to this effect; in case of inconsistencies or errors, messages are\n" + |
| " printed to the error output stream and the result should be considered as non reliable;\n" + |
| " - when only a few changes are made to state names or a specific\n" + |
| " transitions, it should be possible to get the test initializers fixed\n" + |
| " before UnconditionalFlowInfo implements those changes; use the command\n" + |
| " --reinitializeFromComments <states source file> <states target file> <transformations source file> <transformations target file>\n" + |
| " to this effect;\n" + |
| " - the same command can be used when, while the semantics of the system\n" + |
| " are unchanged, the encoding is modified; it should then produce the\n" + |
| " initializers according to the new encoding, as defined by the comment\n" + |
| " for State.states, and the transformations as defined by their\n" + |
| " respective comment;\n" + |
| " - when a given encoding is retained, its optimization may leverage truth\n" + |
| " tables; use the --printTruthTables command to this effect.\n" + |
| " \n\n"); |
| printHelp(false); |
| } |
| else { |
| System.out.println( |
| "Usage:\n" + |
| "Generator --help\n" + |
| " prints a more detailed help message\n" + |
| "Generator --printTruthTables\n" + |
| " prints the truth tables of the transformations\n" + |
| "Generator --reinitializeFromComments <source file> <target file>\n" + |
| " generates into target file a copy of source file into which\n" + |
| " transformations initializers have been reset from their definitions\n" + |
| "Generator --reinitializeFromComputedValues <source file> <target file>\n" + |
| " generates into target file a copy of source file into which\n" + |
| " transformations definitions and initializers have been reset\n" + |
| " according to the behavior of the current UnconditionalFlowInfo\n" |
| ); |
| } |
| } |
| } |
| |