if (i == 2) {
        // Force this request's response to be written to the cache. This way, subsequent responses
        // can be read from the cache.
        System.out.println("Force cache: true");
        clientForCall = client.newBuilder()
            .addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
            .build();
      } else {
        System.out.println("Force cache: false");
        clientForCall = client;

import (
	"testing"
)

func TestSplitPath(t *testing.T) {
	cases := []struct {
		path                          string
		secondIndex                   bool
		expectedListKey, expectedItem string
	}{
		{"format.json", false, "format.json", ""},
		{"users/tester.json", false, "users/", "tester.json"},
		{"groups/test/group.json", false, "groups/", "test/group.json"},
		{"policydb/groups/testgroup.json", true, "policydb/groups/", "testgroup.json"},

        "type": "keyword"
      },
      "queryId": {
        "type": "keyword"
      },
      "searchWord": {
        "type": "keyword"
      },
      "requestedAt": {
        "type": "date",
        "format": "date_optional_time"
      },
      "responseTime": {
        "type": "long"
      },
      "queryTime": {
        "type": "long"
      },
      "hitCount": {
        "type": "long"
      },

  }

  private void expectReturnsTrue(Target target) {
    String message = Platform.format("retainAll(%s) should return true", target);
    assertTrue(message, collection.retainAll(target.toRetain));
  }

  private void expectReturnsFalse(Target target) {
    String message = Platform.format("retainAll(%s) should return false", target);
    assertFalse(message, collection.retainAll(target.toRetain));
  }

            return toShort((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {
                return Short.valueOf(new SimpleDateFormat(pattern).format(o));
            }
            return (short) ((java.util.Date) o).getTime();
        } else if (o instanceof Boolean) {
            return ((Boolean) o) ? (short) 1 : (short) 0;
        } else {

		t.Errorf("User2's name should be updated")
	}

	if user2.UpdatedAt.Format(time.RFC1123Z) == user3.UpdatedAt.Format(time.RFC1123Z) {
		t.Errorf("User's updated at should be changed, old %v, new %v", user2.UpdatedAt.Format(time.RFC1123Z), user3.UpdatedAt.Format(time.RFC1123Z))
	}

	// update with gorm exprs

        // this configuration is on sea_env.properties because it has no influence to production
        // even if you set true manually and forget to set false back
        direction.directFrameworkDebug(fessConfig.isFrameworkDebug()); // basically false

        // you can add your own process when your application is booting or closing

    "$host:$port"
  } else {
    host
  }
}

/** Returns a [Locale.US] formatted [String]. */
internal fun format(
  format: String,
  vararg args: Any,
): String = String.format(Locale.US, format, *args)

/**
 * will also strip BOM from the source
 */
@Throws(IOException::class)
internal fun BufferedSource.readBomAsCharset(default: Charset): Charset =

    JAVA_HOME=$(java-config --jre-home)
  fi
fi

# For Cygwin, ensure paths are in UNIX format before anything is touched
if $cygwin; then
  [ -n "$JAVA_HOME" ] \
    && JAVA_HOME=$(cygpath --unix "$JAVA_HOME")
  [ -n "$CLASSPATH" ] \
    && CLASSPATH=$(cygpath --path --unix "$CLASSPATH")
fi

# For Mingw, ensure paths are in UNIX format before anything is touched
if $mingw; then
  [ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] \

        assertNotNull(resp);
        assertTrue(resp instanceof ServerMessageBlock2Response);
        assertTrue(resp instanceof ServerMessageBlock2);
    }

    @Test
    @DisplayName("Should write empty bytes to wire format")
    void testWriteBytesWireFormat() {
        // Given
        byte[] buffer = new byte[256];
        int offset = 10;

        // When
        int bytesWritten = response.writeBytesWireFormat(buffer, offset);