}
			if err == nil && testCase.expectedErr {
				t.Error(errors.New("expected error, found success"))
			}

			if len(ekvs) != len(testCase.expectedEkvs) {
				t.Errorf("expected %v keys, got %v keys", len(testCase.expectedEkvs), len(ekvs))
			}

			if !reflect.DeepEqual(ekvs, testCase.expectedEkvs) {
				t.Errorf("expected %v, got %v", testCase.expectedEkvs, ekvs)
			}
		})
	}

		callPrime          bool
		wantErr            bool
	}{
		{
			name:             "returns expected secret summary onto Stdout",
			callPrime:        true,
			wantOutputSecret: "testdata/secretsummary.txt",
		},
		{
			name:    "errors if config dump is not primed",
			wantErr: true,
		},
		{
			name:               "returns expected workload summary onto Stdout",
			callPrime:          true,

    UncheckedExecutionException expected =
        assertThrows(
            UncheckedExecutionException.class,
            () -> getChecked(FAILED_FUTURE_UNCHECKED_EXCEPTION, TwoArgConstructorException.class));
    assertThat(expected).hasCauseThat().isEqualTo(UNCHECKED_EXCEPTION);
  }

  public void testGetCheckedUntimed_executionExceptionError() throws TwoArgConstructorException {
    ExecutionError expected =
        assertThrows(

    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Unexpected char 0xe9 at 1 in header name: héader1")
    }
  }

  @Test fun builderRejectsUnicodeInHeaderValue() {
    assertFailsWith<IllegalArgumentException> {
      Headers.Builder().add("header1", "valué1")
    }.also { expected ->
      assertThat(expected.message)

			if err != nil && testCase.success {
				t.Errorf("expected to succeed but failed with %s", err)
			}
			if !testCase.success && err == nil {
				t.Error("expected failure but succeeded instead")
			}
			if testCase.success {
				if !reflect.DeepEqual(endpoints, testCase.endpoints) {
					t.Errorf("expected %s, got %s", testCase.endpoints, endpoints)
				}
				if secure != testCase.secure {

        value = "Fess,フェス";
        expected = Arrays.asList("Fess", "フェス");
        actual = Arrays.asList(KuromojiCSVUtil.parse(value));
        assertThat(actual, is(expected));

        value = "\"Fess,FESS\"";
        expected = Arrays.asList("\"Fess,FESS\"");
        actual = Arrays.asList(KuromojiCSVUtil.parse(value));
        assertThat(actual, is(expected));

        value = " ";

    lockB.lock();
    PotentialDeadlockException expected =
        assertThrows(PotentialDeadlockException.class, () -> lockA.lock());
    checkMessage(expected, "LockB -> LockA", "LockA -> LockB");
    firstException = expected;
    // Second time should also fail, with a cached causal chain.
    expected = assertThrows(PotentialDeadlockException.class, () -> lockA.lock());
    checkMessage(expected, "LockB -> LockA", "LockA -> LockB");

    lockB.lock();
    PotentialDeadlockException expected =
        assertThrows(PotentialDeadlockException.class, () -> lockA.lock());
    checkMessage(expected, "LockB -> LockA", "LockA -> LockB");
    firstException = expected;
    // Second time should also fail, with a cached causal chain.
    expected = assertThrows(PotentialDeadlockException.class, () -> lockA.lock());
    checkMessage(expected, "LockB -> LockA", "LockA -> LockB");

	locked := testSimpleWriteLock(t, 5*time.Second)

	expected := true
	if locked != expected {
		t.Errorf("TestSimpleWriteLockAcquired(): \nexpected %#v\ngot      %#v", expected, locked)
	}
}

func TestSimpleWriteLockTimedOut(t *testing.T) {
	locked := testSimpleWriteLock(t, time.Second)

	expected := false
	if locked != expected {
		t.Errorf("TestSimpleWriteLockTimedOut(): \nexpected %#v\ngot      %#v", expected, locked)
	}
}

	if batchLen != 0 {
		t.Fatalf("Expected batch.Len()=0; but got %v", batchLen)
	}

	keys := store.List()
	if len(keys) != 1 {
		t.Fatalf("expected len(store.List())=1; but got %v", len(keys))
	}

	key := keys[0]
	if !key.Compress {
		t.Fatal("expected key.Compress=true; but got false")
	}
	if key.ItemCount != int(limit) {
		t.Fatalf("expected key.ItemCount=%d; but got %v", limit, key.ItemCount)
	}