1 files changed, 153 insertions, 0 deletions
diff --git a/src/test/java/com/code_intelligence/jazzer/instrumentor/TraceDataFlowInstrumentationTarget.java b/src/test/java/com/code_intelligence/jazzer/instrumentor/TraceDataFlowInstrumentationTarget.java
new file mode 100644
index 00000000..d8e28881
--- /dev/null
+++ b/src/test/java/com/code_intelligence/jazzer/instrumentor/TraceDataFlowInstrumentationTarget.java
@@ -0,0 +1,153 @@
+// Copyright 2021 Code Intelligence GmbH
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.code_intelligence.jazzer.instrumentor;
+
+import java.nio.ByteBuffer;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+import java.util.Vector;
+
+public class TraceDataFlowInstrumentationTarget implements DynamicTestContract {
+  volatile long long1 = 1;
+  volatile long long2 = 1;
+  volatile long long3 = 2;
+  volatile long long4 = 3;
+
+  volatile int int1 = 4;
+  volatile int int2 = 4;
+  volatile int int3 = 6;
+  volatile int int4 = 5;
+
+  volatile int switchValue = 1200;
+
+  @SuppressWarnings("ReturnValueIgnored")
+  @Override
+  public Map<String, Boolean> selfCheck() {
+    Map<String, Boolean> results = new HashMap<>();
+
+    results.put("longCompareEq", long1 == long2);
+    results.put("longCompareNe", long3 != long4);
+
+    results.put("intCompareEq", int1 == int2);
+    results.put("intCompareNe", int3 != int4);
+    results.put("intCompareLt", int4 < int3);
+    results.put("intCompareLe", int4 <= int3);
+    results.put("intCompareGt", int3 > int4);
+    results.put("intCompareGe", int3 >= int4);
+
+    // Not instrumented since all case values are non-negative and < 256.
+    switch (switchValue) {
+      case 119:
+      case 120:
+      case 121:
+        results.put("tableSwitchUninstrumented", false);
+        break;
+      default:
+        results.put("tableSwitchUninstrumented", true);
+    }
+
+    // Not instrumented since all case values are non-negative and < 256.
+    switch (switchValue) {
+      case 1:
+      case 200:
+        results.put("lookupSwitchUninstrumented", false);
+        break;
+      default:
+        results.put("lookupSwitchUninstrumented", true);
+    }
+
+    results.put("emptySwitchUninstrumented", false);
+    switch (switchValue) {
+      default:
+        results.put("emptySwitchUninstrumented", true);
+    }
+
+    switch (switchValue) {
+      case 1000:
+      case 1001:
+        // case 1002: The tableswitch instruction will contain a gap case for 1002.
+      case 1003:
+        results.put("tableSwitch", false);
+        break;
+      default:
+        results.put("tableSwitch", true);
+    }
+
+    switch (-switchValue) {
+      case -1200:
+        results.put("lookupSwitch", true);
+        break;
+      case -1:
+      case -10:
+      case -1000:
+      case 200:
+      default:
+        results.put("lookupSwitch", false);
+    }
+
+    results.put("intDiv", (int3 / 2) == 3);
+
+    results.put("longDiv", (long4 / 2) == 1);
+
+    String[] referenceArray = {"foo", "foo", "bar"};
+    boolean[] boolArray = {false, false, true};
+    byte[] byteArray = {0, 0, 2};
+    char[] charArray = {0, 0, 0, 3};
+    double[] doubleArray = {0, 0, 0, 0, 4};
+    float[] floatArray = {0, 0, 0, 0, 0, 5};
+    int[] intArray = {0, 0, 0, 0, 0, 0, 6};
+    long[] longArray = {0, 0, 0, 0, 0, 0, 0, 7};
+    short[] shortArray = {0, 0, 0, 0, 0, 0, 0, 0, 8};
+
+    results.put("referenceArrayGep", referenceArray[2].equals("bar"));
+    results.put("boolArrayGep", boolArray[2]);
+    results.put("byteArrayGep", byteArray[2] == 2);
+    results.put("charArrayGep", charArray[3] == 3);
+    results.put("doubleArrayGep", doubleArray[4] == 4);
+    results.put("floatArrayGep", floatArray[5] == 5);
+    results.put("intArrayGep", intArray[6] == 6);
+    results.put("longArrayGep", longArray[7] == 7);
+    results.put("shortArrayGep", shortArray[8] == 8);
+
+    ByteBuffer buffer = ByteBuffer.allocate(100);
+    buffer.get(2);
+    buffer.getChar(3);
+    buffer.getDouble(4);
+    buffer.getFloat(5);
+    buffer.getInt(6);
+    buffer.getLong(7);
+    buffer.getShort(8);
+
+    "foobarbazbat".charAt(9);
+    "foobarbazbat".codePointAt(10);
+    new StringBuilder("foobarbazbat").charAt(11);
+
+    (new Vector<>(Collections.nCopies(20, "foo"))).get(12);
+    (new ArrayList<>(Collections.nCopies(20, "foo"))).get(13);
+    Stack<String> stack = new Stack<>();
+    for (int i = 0; i < 20; i++) stack.push("foo");
+    stack.get(14);
+    stack.get(15);
+    ((AbstractList<String>) stack).get(16);
+    ((List<String>) stack).get(17);
+
+    return results;
+  }
+}