@Test
        void knownErrorCodes() {
            assertEquals(71, WinError.ERROR_REQ_NOT_ACCEP, "ERROR_REQ_NOT_ACCEP expected 71");
            assertEquals(230, WinError.ERROR_BAD_PIPE, "ERROR_BAD_PIPE expected 230");
            assertEquals(6118, WinError.ERROR_NO_BROWSER_SERVERS_FOUND, "ERROR_NO_BROWSER_SERVERS_FOUND expected 6118");
        }
    }

    @Nested
    @DisplayName("Array content checks")
    class ArrayChecks {

  public void testFromInt() {
    for (ExpectedHashCode expected : expectedHashCodes) {
      if (expected.bytes.length == 4) {
        HashCode fromInt = HashCode.fromInt(expected.asInt);
        assertExpectedHashCode(expected, fromInt);
      }
    }
  }

  // expectedHashCodes must contain at least one hash code with 8 bytes
  public void testFromLong() {
    for (ExpectedHashCode expected : expectedHashCodes) {

        hasher.putInt(intToPut);
      }
      for (Sink sink : sinks) {
        HashCode unused = sink.hash();
      }

      byte[] expected = controlSink.hash().asBytes();
      for (Sink sink : sinks) {
        sink.assertInvariants(expected.length);
        sink.assertBytes(expected);
      }
    }
  }

  private static class Sink extends AbstractStreamingHasher {
    final int chunkSize;

	tok := in.Stack.Next()
	if tok != scanner.Int {
		in.expectText("expected line number after #line")
	}
	line, err := strconv.Atoi(in.Stack.Text())
	if err != nil {
		in.Error("error parsing #line (cannot happen):", err)
	}
	tok = in.Stack.Next()
	if tok != scanner.String {
		in.expectText("expected file name in #line")
	}
	file, err := strconv.Unquote(in.Stack.Text())
	if err != nil {

  }

  private static void assertHash(int seed, long expected1, long expected2, String stringInput) {
    HashCode expected = toHashCode(expected1, expected2);
    byte[] input = HashTestUtils.ascii(stringInput);
    assertEquals(expected, murmur3_128(seed).hashBytes(input));
    assertEquals(expected, murmur3_128(seed).newHasher().putBytes(input).hash());
  }

		if err != nil {
			t.Fatalf("expected: <nil>, got: %s", err)
		}

		start, length, err1 := rs.GetOffsetLength(objectSize)
		if err1 != nil {
			t.Fatalf("expected: <nil>, got: %s", err1)
		}

		if start != successCase.offsetBegin {
			t.Fatalf("expected: %d, got: %d", successCase.offsetBegin, start)
		}

		if start+length-1 != successCase.offsetEnd {

          .isEqualTo(value);
    }
  }

  public void testFromIntBitsLongValue() {
    for (int value : TEST_INTS) {
      long expected = value & 0xffffffffL;
      assertWithMessage(UnsignedInts.toString(value))
          .that(UnsignedInteger.fromIntBits(value).longValue())
          .isEqualTo(expected);
    }
  }

  public void testValueOfLong() {
    long min = 0;
    long max = (1L << 32) - 1;

    public void test_shutdown_withoutListener() {
        // Call shutdown without setting listener
        try {
            scriptExecutor.shutdown();
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
            // Expected behavior when no listener is set
        }
    }

    public void test_addShutdownListener_replacesExisting() {
        // Add first listener

            fail("Should throw ScheduledJobException");
        } catch (ScheduledJobException e) {
            assertEquals("No job.", e.getMessage());
        } catch (Exception e) {
            // Expected due to missing dependencies in test environment
            assertTrue(true);
        }
    }

    public void test_register_with_cron_null_scheduledJob() {
        try {

    @Test
    public void testReadParameterWordsWireFormat() {
        // This method is expected to do nothing and return 0
        int result = smbComQueryInformation.readParameterWordsWireFormat(new byte[0], 0);
        assertEquals(0, result);
    }

    @Test
    public void testReadBytesWireFormat() {
        // This method is expected to do nothing and return 0