} catch (Throwable t) {
                  thrown.set(t);
                }
              }
            }));
    assertThat(thrown.get()).isNull();
    assertEquals(expectedIsOccupied, actualIsOccupied.get());
    assertEquals(expectedIsOccupiedByCurrentThread, actualIsOccupiedByCurrentThread.get());
    assertEquals(expectedOccupiedDepth, actualOccupiedDepth.get());

                } catch (Throwable t) {
                  thrown.set(t);
                }
              }
            }));
    assertThat(thrown.get()).isNull();
    assertEquals(expectedIsOccupied, actualIsOccupied.get());
    assertEquals(expectedIsOccupiedByCurrentThread, actualIsOccupiedByCurrentThread.get());
    assertEquals(expectedOccupiedDepth, actualOccupiedDepth.get());

    HostAndPort hp;
    try {
      hp = HostAndPort.fromString(hpString);
    } catch (IllegalArgumentException e) {
      // Make sure we expected this.
      assertThat(expectHost).isNull();
      return;
    }
    assertThat(expectHost).isNotNull();

    // Apply withDefaultPort(), yielding hp2.
    boolean badDefaultPort = defaultPort < 0 || defaultPort > 65535;
    HostAndPort hp2 = null;

    HostAndPort hp;
    try {
      hp = HostAndPort.fromString(hpString);
    } catch (IllegalArgumentException e) {
      // Make sure we expected this.
      assertThat(expectHost).isNull();
      return;
    }
    assertThat(expectHost).isNotNull();

    // Apply withDefaultPort(), yielding hp2.
    boolean badDefaultPort = defaultPort < 0 || defaultPort > 65535;
    HostAndPort hp2 = null;

    assertValueAndTypeEquals(expected, generator.generateFresh(type));
    assertThat(generator.generateFresh(type)).isNull();
  }

  private static void assertNotInstantiable(TypeToken<?> type) {
    assertThat(new FreshValueGenerator().generateFresh(type)).isNull();
  }

  private static void assertValueAndTypeEquals(Object expected, Object actual) {
    assertEquals(expected, actual);

    sendRequest(methodName, arguments);
    Thread.sleep(DUE_DILIGENCE_MILLIS);
    assertEquals(true, invokeMethod("hasQueuedThread", this));
    assertThat(responseQueue.poll()).isNull();
  }

  /**
   * Causes this thread to call the named method, and asserts that this thread thereby waits on the
   * given condition-like object. The lock-like object must have a method equivalent to {@link

    }
  }

  void checkEmpty(BlockingQueue<?> q) {
    try {
      assertTrue(q.isEmpty());
      assertEquals(0, q.size());
      assertThat(q.peek()).isNull();
      assertThat(q.poll()).isNull();
      assertThat(q.poll(0, MILLISECONDS)).isNull();
      assertEquals("[]", q.toString());
      assertThat(q.toArray()).isEmpty();
      assertFalse(q.iterator().hasNext());
      try {
        q.element();

                            + "Found " + repositories.size() + " repositories but only " + set.size()
                            + " unique entries.");
        }
        if (repositories.stream().anyMatch(Objects::isNull)) {
            throw new IllegalArgumentException(
                    "Repository list contains null entries. All repository entries must be non-null RemoteRepository instances.");
        }
        return repositories;

				return updatedAt, err
			}
			// find a single expiry rule set the flag
			for _, rl := range lcCfg.Rules {
				if !rl.Expiration.IsNull() || !rl.NoncurrentVersionExpiration.IsNull() {
					expiryRuleRemoved = true
					break
				}
			}
		}

		// Form empty ILM details with `ExpiryUpdatedAt` field and save
		var cfgData []byte
		if expiryRuleRemoved {

			tests = append(tests, test{
				name: fmt.Sprint(a.GetTypeString(), "!=", b.GetTypeString()),
				fields: fields{
					a: *a, b: *b,
				},
				// Only Null == Null
				wantOk: a.IsNull() && b.IsNull() && i == 0 && j == 0,
			})
		}
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if gotOk := tt.fields.a.Equals(tt.fields.b); gotOk != tt.wantOk {