import jcifs.smb1.smb1.NtlmPasswordAuthentication;

/**
 * @author shinsuke
 *
 */
public class SmbAuthentication {
    private String server;

    private int port;

    private String username;

    private String password;

    private String domain;

    public String getPathPrefix() {
        final StringBuilder buf = new StringBuilder(100);
        buf.append("smb1://");
        if (server != null) {

abstract class ExtensibleEnums {

    static Language language(String id) {
        return new DefaultLanguage(id);
    }

    static PathScope pathScope(String id, ProjectScope projectScope, DependencyScope... dependencyScopes) {
        return new DefaultPathScope(id, projectScope, dependencyScopes);
    }

    static ProjectScope projectScope(String id) {
        return new DefaultProjectScope(id);
    }

	// map header, size 5
	// string "Name"
	o = append(o, 0x85, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Name)
	// string "Created"
	o = append(o, 0xa7, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64)
	o = msgp.AppendTime(o, z.Created)
	// string "Deleted"
	o = append(o, 0xa7, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64)
	o = msgp.AppendTime(o, z.Deleted)
	// string "Versioning"

}

type realDeps struct{}

func (m *realDeps) ipsetIPHashCreate(name string, v6 bool) error {
	return errors.New("not implemented on this platform")
}

func (m *realDeps) destroySet(name string) error {
	return errors.New("not implemented on this platform")
}

func (m *realDeps) addIP(name string, ip netip.Addr, ipProto uint8, comment string, replace bool) error {
	return errors.New("not implemented on this platform")
}

        }
    }

    public void scriptedMetric(String name, ConditionOptionCall<ScriptedMetricAggregationBuilder> opLambda) {
        ScriptedMetricAggregationBuilder builder = regScriptedMetricA(name);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void topHits(String name, ConditionOptionCall<TopHitsAggregationBuilder> opLambda) {

    protected String searchPreference;

    protected String[] targetIndices;

    public FesenClient() {
        address = System.getProperty(HTTP_ADDRESS, "localhost:9200").trim();
        final String targets = System.getProperty(TARGET_INDICES);
        if (StringUtil.isNotBlank(targets)) {
            targetIndices = Arrays.stream(targets.split(",")).map(String::trim).toArray(n -> new String[n]);
        }

			Optional:    true,
			Type:        "string",
		},
		config.HelpKV{
			Key:         target.AmqpExchangeType,
			Description: "AMQP exchange type",
			Optional:    true,
			Type:        "string",
		},
		config.HelpKV{
			Key:         target.AmqpRoutingKey,
			Description: "routing key for publishing",
			Optional:    true,
			Type:        "string",
			Sensitive:   true,
		},
		config.HelpKV{

public class MapsTransformValuesTest extends AbstractMapsTransformValuesTest {
  @Override
  protected Map<String, String> makeEmptyMap() {
    return transformValues(Maps.<String, String>newHashMap(), Functions.<String>identity());
  }

  @Override
  protected Map<String, String> makePopulatedMap() {
    Map<String, Integer> underlying = Maps.newHashMap();
    underlying.put("a", 1);
    underlying.put("b", 2);

            }
        };
        crawlerStatsHelper.init();
    }

    public void test_beginDone() {
        String key = "test";
        crawlerStatsHelper.begin(key);
        crawlerStatsHelper.done(key);
        logger.info(localLogMsg.get());
        String[] values = localLogMsg.get().split("\t");
        assertEquals(3, values.length);
        assertEquals("url:test", values[0]);

    .build()
}

val Response.commonIsSuccessful: Boolean
  get() = code in 200..299

fun Response.commonHeaders(name: String): List<String> = headers.values(name)

@JvmOverloads
fun Response.commonHeader(
  name: String,
  defaultValue: String?,
): String? = headers[name] ?: defaultValue

@Throws(IOException::class)
fun Response.commonPeekBody(byteCount: Long): ResponseBody {