NullabilityBreakingChangesRule(Map<String, Object> params) {
        super(params)
    }

    @Override
    Violation maybeViolation(JApiCompatibility member) {

        if (isNewOrRemoved(member)) {
            return null
        }

        List<String> warnings = []
        List<String> errors = []

    registerParamProvider(access, "okhttp3.WebPlatformUrlTest\$TestDataParamProvider")
  }

  private fun registerParamProvider(
    access: Feature.BeforeAnalysisAccess,
    provider: String,
  ) {
    val providerClass = access.findClassByName(provider)
    if (providerClass != null) {
      registerTest(access, providerClass)
    } else {
      println("Missing $provider")
    }
  }

  @CanIgnoreReturnValue // to skip some bytes
  @Override
  double readDouble();

  @CanIgnoreReturnValue // to skip a line
  @Override
  @CheckForNull
  String readLine();

  @CanIgnoreReturnValue // to skip a field
  @Override
  String readUTF();

    protected abstract Credentials getDefaultCredentials ();


    /**
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#renewCredentials(java.lang.String, java.lang.Throwable)
     */
    @Override
    public boolean renewCredentials ( String locationHint, Throwable error ) {
        return false;
    }


    /**
     * {@inheritDoc}
     * 
     *
     * @see jcifs.CIFSContext#close()

        } else {
            aces = null;
        }

        return bufferIndex - start;
    }
    public String toString() {
        String ret = "SecurityDescriptor:\n";
        if (aces != null) {
            for (int ai = 0; ai < aces.length; ai++) {
                ret += aces[ai].toString() + "\n";
            }
        } else {
            ret += "NULL";
        }
        return ret;
    }

		}
		cfgData = subSys + tgtSuffix + config.KvSpaceSeparator + string(reqBytes)
	}

	cfg, err := readServerConfig(ctx, objectAPI, nil)
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	dynamic, err := cfg.ReadConfig(strings.NewReader(cfgData))
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)

public class UuidUtilTest extends TestCase {

    /**
     * Test method for {@link org.codelibs.core.net.UuidUtil#create()}.
     */
    public void testCreate() {
        final String uuid = UuidUtil.create();
        System.out.println(uuid);
        final String uuid2 = UuidUtil.create();
        System.out.println(uuid2);
        assertFalse(uuid.equals(uuid2));
    }

package gradlebuild.identity.model

import org.gradle.util.GradleVersion

import java.text.SimpleDateFormat
import java.util.Date
import java.util.TimeZone


data class ReleasedVersion(val version: String, val buildTime: String) {
    fun gradleVersion() = GradleVersion.version(version)
    fun buildTimeStamp(): Date = SimpleDateFormat("yyyyMMddHHmmssZ").apply { timeZone = TimeZone.getTimeZone("UTC") }.parse(buildTime)

/**
 * @author shinsuke
 */
public class CreateForm {

    @ValidateTypeFailure
    public Integer crudMode;

    public Map<String, Object> doc;

    public String q;

    public void initialize() {
        crudMode = CrudMode.CREATE;
    }

	}
}

// TestWriterComment is test for EOCD comment read/write.
func TestWriterComment(t *testing.T) {
	tests := []struct {
		comment string
		ok      bool
	}{
		{"hi, hello", true},
		{"hi, こんにちわ", true},
		{strings.Repeat("a", uint16max), true},
		{strings.Repeat("a", uint16max+1), false},
	}

	for _, test := range tests {
		// write a zip file
		buf := new(bytes.Buffer)
		w := NewWriter(buf)