expectErr := (err != nil)

		if expectErr != testCase.expectErr {
			t.Fatalf("case %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}
		if err != errUnformattedDisk {
			t.Fatalf("case %v: error: expected: %v, got: %v", i+1, errUnformattedDisk, err)
		}
	}
}

func testStorageAPIStatInfoFile(t *testing.T, storage StorageAPI) {

sitea_out=$(cat /tmp/sitea_dirs.txt)
siteb_out=$(cat /tmp/siteb_dirs.txt)

if [ $sitea_count -ne 0 ]; then
	echo "BUG: expected no 'directory objects' left after deletion: ${sitea_out}"
	exit 1
fi

if [ $siteb_count -ne 0 ]; then
	echo "BUG: expected no 'directory objects' left after deletion: ${siteb_out}"
	exit 1
fi

    assertFailsWith<IllegalArgumentException> {
      windowUpdate(0)
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("windowSizeIncrement == 0 || windowSizeIncrement > 0x7fffffffL: 0")
    }
    assertFailsWith<IllegalArgumentException> {
      windowUpdate(0x80000000L)
    }.also { expected ->
      assertThat(expected.message)

    }

    private void checkArtifactResult(ArtifactResult result, String filename) {
        assertFalse(result.isMissing(), "Expected " + result + ".isMissing() to return false");
        assertTrue(result.isResolved(), "Expected " + result + ".isResolved() to return true");
        Artifact artifact = result.getArtifact();
        assertNotNull(artifact.getFile());

    taskRunner.newQueue().execute("connect") {
      assertFailsWith<IOException> {
        finder.find()
      }.also { expected ->
        assertThat(expected).hasMessage("boom 0!")
        assertThat(expected.suppressed.single()).hasMessage("boom 1!")
      }
    }

    taskFaker.runTasks()
    assertEvents(
      "take plan 0",
      "plan 0 TCP connecting...",

        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;

        int expected;
        if (errcode == 0) {
            expected = 0;
        } else if ((errcode & 0xC0000000) != 0) {
            // Negative values with 0xC0000000 bits set are returned as-is
            expected = errcode;
        } else {
            // Positive values not in DOS_ERROR_CODES map to NT_STATUS_UNSUCCESSFUL
            expected = NtStatus.NT_STATUS_UNSUCCESSFUL;
        }

		result := testCase.set.Clone()

		if !reflect.DeepEqual(result, testCase.set) {
			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.set, result)
		}

		result.add(testCase.targetIDToAdd)
		if reflect.DeepEqual(result, testCase.set) {
			t.Fatalf("test %v: result: expected: not equal, got: equal", i+1)
		}
	}
}

func TestTargetIDSetUnion(t *testing.T) {
	testCases := []struct {

      }
      assertEquivalent(expectedResult, collector.finisher().apply(finalAccum));
    }
  }

  private void assertEquivalent(R expected, R actual) {
    assertTrue(
        "Expected " + expected + " got " + actual + " modulo equivalence " + equivalence,
        equivalence.test(expected, actual));
  }

    void constructorMasksValue(int input) {
        NdrShort ns = new NdrShort(input);
        // NdrShort masks to 0xFF (8 bits) in its constructor
        int expected = input & 0xFF;
        assertEquals(expected, ns.value, "value should be masked to 0xFF before storing");
    }

    /**
     * Round-trip encode/decode for a selection of representative values.
     */
    @ParameterizedTest