{"3^4", 3 ^ 4, true},
	{"3*4", 3 * 4, true},
	{"14/4", 14 / 4, true},
	{"3<<4", 3 << 4, true},
	{"48>>3", 48 >> 3, true},
	{"3&9", 3 & 9, true},
	// General
	{"3*2+3", 3*2 + 3, true},
	{"3+2*3", 3 + 2*3, true},
	{"3*(2+3)", 3 * (2 + 3), true},
	{"3*-(2+3)", 3 * -(2 + 3), true},
	{"3<<2+4", 3<<2 + 4, true},
	{"3<<2+4", 3<<2 + 4, true},
	{"3<<(2+4)", 3 << (2 + 4), true},
	// Junk at EOF.
	{"3 x", 3, false},
	// Big number

            "1, 1, true", // ATTR_READONLY
            "2, 2, true", // ATTR_HIDDEN
            "4, 4, true", // ATTR_SYSTEM
            "16, 16, true", // ATTR_DIRECTORY
            "32, 32, true", // ATTR_ARCHIVE
            "3, 1, true", // READONLY | HIDDEN vs READONLY
            "3, 2, true", // READONLY | HIDDEN vs HIDDEN
            "3, 3, true", // READONLY | HIDDEN vs READONLY | HIDDEN

	{"(R9)(BX*8)", "(R9)(BX*8)"},
	{"(SI)", "(SI)"},
	{"(SI)(BX*1)", "(SI)(BX*1)"},
	{"(SI)(DX*1)", "(SI)(DX*1)"},
	{"(SP)", "(SP)"},
	{"(SP)(AX*4)", "(SP)(AX*4)"},
	{"32(SP)(BX*2)", "32(SP)(BX*2)"},
	{"32323(SP)(R8*4)", "32323(SP)(R8*4)"},
	{"+3(PC)", "3(PC)"},
	{"-1(DI)(BX*1)", "-1(DI)(BX*1)"},
	{"-3(PC)", "-3(PC)"},
	{"-64(SI)(BX*1)", "-64(SI)(BX*1)"},
	{"-96(SI)(BX*1)", "-96(SI)(BX*1)"},
	{"AL", "AL"},

    ImmutableValueGraph<Integer, String> graph =
        ValueGraphBuilder.directed()
            .<Integer, String>immutable()
            .putEdgeValue(2, 1, "2-1")
            .putEdgeValue(2, 3, "2-3")
            .putEdgeValue(1, 2, "1-2")
            .build();

    assertThat(graph.incidentEdges(2))
        .containsExactly(

    graph = ValueGraphBuilder.directed().incidentEdgeOrder(ElementOrder.stable()).build();
    graph.putEdgeValue(2, 1, "2-1");
    graph.putEdgeValue(2, 3, "2-3");
    graph.putEdgeValue(1, 2, "1-2");

    assertThat(graph.incidentEdges(2))
        .containsExactly(
            EndpointPair.ordered(2, 1), EndpointPair.ordered(2, 3), EndpointPair.ordered(1, 2))

  @Test
  public void hasCycle_cyclicMultigraph() {
    for (MutableNetwork<Integer, String> network : networksToTest) {
      network.addEdge(1, 2, "1-2a");
      network.addEdge(1, 2, "1-2b");
      network.addEdge(2, 3, "2-3");
      network.addEdge(3, 1, "3-1");
    }
    assertThat(hasCycle(directedNetwork)).isTrue();
    assertThat(hasCycle(undirectedNetwork)).isTrue();
  }

  @Test

    graph = ValueGraphBuilder.directed().incidentEdgeOrder(ElementOrder.stable()).build();
    graph.putEdgeValue(2, 1, "2-1");
    graph.putEdgeValue(2, 3, "2-3");
    graph.putEdgeValue(1, 2, "1-2");

    assertThat(graph.incidentEdges(2))
        .containsExactly(
            EndpointPair.ordered(2, 1), EndpointPair.ordered(2, 3), EndpointPair.ordered(1, 2))

    // Default configuration
    private static final int DEFAULT_HASH_ALGORITHM = HASH_ALGO_SHA512;
    private static final int SALT_SIZE = 32; // 32 bytes as per SMB 3.1.1 spec
    private static final int HASH_SIZE_SHA512 = 64; // SHA-512 produces 64-byte hashes

    // Session-specific preauth integrity contexts

            // Test with various combinations
            context = new PreauthIntegrityNegotiateContext(mockConfig, new int[3], new byte[32]);
            assertEquals(4 + 6 + 32, context.size()); // header + 3*2 + 32

            context = new PreauthIntegrityNegotiateContext(mockConfig, null, new byte[16]);
            assertEquals(4 + 16, context.size());

    X2309,
    X2310,
    X2311,
    X2312,
    X2313,
    X2314,
    X2315,
    X2316,
    X2317,
    X2318,
    X2319,
    X2320,
    X2321,
    X2322,
    X2323,
    X2324,
    X2325,
    X2326,
    X2327,
    X2328,
    X2329,
    X2330,
    X2331,
    X2332,
    X2333,
    X2334,
    X2335,
    X2336,
    X2337,