options.color().ifPresent(color -> {
            String c = color.toLowerCase(Locale.ENGLISH);
            if (!Arrays.asList("always", "yes", "force", "never", "no", "none", "auto", "tty", "if-tty")
                    .contains(c)) {
                context.parsingFailed = true;
                context.parserRequest

        // Test match
        ResponseData responseData = new ResponseData();
        assertTrue(rule.match(responseData));
        assertEquals(1, rule.getMatchCallCount());
    }

    /**
     * Test Rule with always true match
     */
    public void test_ruleAlwaysMatch() {
        TestResponseProcessor processor = new TestResponseProcessor("alwaysMatch");
        TestRule rule = new TestRule("alwaysRule", processor, true);

    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

  /**
   * Returns a function that ignores its input and always returns {@code value}.
   *
   * <p>Prefer to use the lambda expression {@code o -> value} instead. Note that it is not
   * serializable unless you explicitly make it {@link Serializable}, typically by writing {@code

      this.delegate = checkNotNull(delegate);
    }

    @Override
    @ParametricNullness
    @SuppressWarnings("unchecked") // Cast from Supplier<Void> to Supplier<T> is always valid
    public T get() {
      // Because Supplier is read-heavy, we use the "double-checked locking" pattern.
      if (delegate != SUCCESSFULLY_COMPUTED) {
        synchronized (lock) {

	if err != nil {
		// Return empty listing
		return ListObjectsV2Info{}, nil
	}

	zipInfo := zipObjInfo.ArchiveInfo(h)
	if len(zipInfo) == 0 {
		// Always update the latest version
		zipInfo, err = updateObjectMetadataWithZipInfo(ctx, objectAPI, bucket, zipPath, ObjectOptions{})
	}
	if err != nil {
		return ListObjectsV2Info{}, err
	}

          /* Someone beat us to it! Trying again...
           *
           * Technically this loop not guaranteed to terminate, so theoretically (extremely
           * unlikely) this thread might starve, but even then, there is always going to be another
           * thread doing progress here.
           */
        }
      }
    }
  }

  /**

        }
    }

    @Nested
    @DisplayName("ReadBytesWireFormat Tests")
    class ReadBytesWireFormatTests {

        @Test
        @DisplayName("Should always return 0")
        void testReadBytesWireFormat() {
            byte[] buffer = new byte[100];

            int bytesRead = echoRequest.readBytesWireFormat(buffer, 0);

            assertEquals(0, bytesRead);

           */
          toJoin = Arrays.copyOf(toJoin, expandedCapacity(toJoin.length, toJoin.length + 1));
        }
        toJoin[i++] = toString(part);
      }
      // We might not have seen the expected number of elements, as discussed above.
      if (i != toJoin.length) {
        toJoin = Arrays.copyOf(toJoin, i);
      }
      return String.join(separator, toJoin);
    }

		// If body is > 10MB, drop it.
		if lrw.bytesWritten+len(p) > 10<<20 {
			lrw.LogAllBody = false
			lrw.body = bytes.Buffer{}
		} else {
			// Always logging error responses.
			lrw.body.Write(p)
		}
	}
	if err != nil {
		return n, err
	}
	return n, err
}

// Write the headers into the given buffer

        int bodyOffset = Smb2Constants.SMB2_HEADER_LENGTH;

        // Verify token length is 0
        assertEquals(0, SMBUtil.readInt2(buffer, bodyOffset + 14));
    }

    @Test
    @DisplayName("Should always return 0 for readBytesWireFormat")
    void testReadBytesWireFormat() {
        // Given
        byte[] buffer = createTestData(256);

        // When
        int bytesRead = request.readBytesWireFormat(buffer, 0);