if foundPrefix != test.commonPrefix {
			t.Fatalf("Test %d: Common prefix found: `%v`, expected: `%v`", i+1, foundPrefix, test.commonPrefix)
		}
	}
}

func TestGetMinioMode(t *testing.T) {
	testMinioMode := func(expected string) {
		if mode := getMinioMode(); mode != expected {
			t.Fatalf("Expected %s got %s", expected, mode)
		}
	}
	globalIsDistErasure = true
	testMinioMode(globalMinioModeDistErasure)

            }
          }

        TYPE_IGNORED, TYPE_VALID, TYPE_DISALLOWED -> {
          MappedRange.Constant(rangeStart, mapping.type)
        }

        else -> error("unexpected mapping type: ${mapping.type}")
      }
  }

  for (sectionList in result.values) {
    mergeAdjacentDeltaMappedRanges(sectionList)
  }

  return result.toMap()
}

/**

			}

			for i, sum := range chksums {
				if i >= len(v.chksums) {
					t.Fatalf("entry %d: unexpected sum: got %s", i, sum)
				}
				if sum != v.chksums[i] {
					t.Fatalf("entry %d: incorrect checksum: got %s, want %s", i, sum, v.chksums[i])
				}
			}

			if err != v.err {
				t.Fatalf("unexpected error: got %v, want %v", err, v.err)
			}
			f.Close()
		})
	}
}

      Request
        .Builder()
        .url("https://publicobject.com/robots.txt")
        .build()

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      for (certificate in response.handshake!!.peerCertificates) {
        println(CertificatePinner.pin(certificate))
      }
    }
  }
}

fun main() {
  CertificatePinning().run()

	}

	// 4. List groups and members and verify
	groups, err := s.adm.ListGroups(ctx)
	if err != nil {
		c.Fatalf("group list err: %v", err)
	}
	expected := []string{group}
	if !slices.Equal(groups, expected) {
		c.Fatalf("expected group listing: %v, got: %v", expected, groups)
	}
	groupInfo, err := s.adm.GetGroupDescription(ctx, group)
	if err != nil {
		c.Fatalf("group desc err: %v", err)
	}

    TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
    if (trustManagers.length != 1 || !(trustManagers[0] instanceof X509TrustManager)) {
      throw new IllegalStateException("Unexpected default trust managers:"
          + Arrays.toString(trustManagers));
    }
    return (X509TrustManager) trustManagers[0];
  }

  private String[] javaNames(List<CipherSuite> cipherSuites) {

		},
	}
	for i, test := range cases {
		listKey, item := splitPath(test.path, test.secondIndex)
		if listKey != test.expectedListKey || item != test.expectedItem {
			t.Errorf("unexpected result on test[%v]: expected[%s, %s] but got [%s, %s]", i, test.expectedListKey, test.expectedItem, listKey, item)
		}
	}

            break@afterBoundaryLoop
          }

          1 -> {
            // "--": No more parts.
            if (whitespace) throw ProtocolException("unexpected characters after boundary")
            if (partCount == 0) throw ProtocolException("expected at least 1 part")
            noMoreParts = true
            return null
          }

          2, 3 -> {

    factory.init(trustStore)
    val result = factory.trustManagers!!
    check(result.size == 1 && result[0] is X509TrustManager) {
      "Unexpected trust managers: ${result.contentToString()}"
    }

    val trustManager = result[0] as X509TrustManager

    return when {
      insecureHosts.isEmpty() -> trustManager

        .url("https://publicobject.com/robots.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      for (Certificate certificate : response.handshake().peerCertificates()) {
        System.out.println(CertificatePinner.pin(certificate));
      }
    }
  }