Sets.difference(graph.successors(node), ImmutableSet.of(node)).iterator(),
                          (N successor) -> EndpointPair.ordered(node, successor))));
            } else {
              return Iterators.unmodifiableIterator(
                  Iterators.transform(
                      graph.adjacentNodes(node).iterator(),

 * limitations under the License.
 */
package okhttp3.testing

object PlatformVersion {
  val majorVersion: Int by lazy {
    when (val jvmSpecVersion = getJvmSpecVersion()) {
      "1.8" -> 8
      else -> jvmSpecVersion.toInt()
    }
  }

  fun getJvmSpecVersion(): String = System.getProperty("java.specification.version", "unknown")

        final String executeType = System.getProperty("lasta.env");
        if (Constants.EXECUTE_TYPE_CRAWLER.equalsIgnoreCase(executeType)) {
            ptList.add(Constants.PROCESS_TYPE_REPLACE);
        } else {
            ptList.add(Constants.PROCESS_TYPE_DISPLAYING);
            ptList.add(Constants.PROCESS_TYPE_BOTH);
        }
        return ptList;
    }

    /**

    long result;

    if (length <= 32) {
      result = murmurHash64WithSeed(bytes, offset, length, K0 ^ K1 ^ K2);
    } else if (length <= 64) {
      result = hashLength33To64(bytes, offset, length);
    } else {
      result = fullFingerprint(bytes, offset, length);
    }

    long u = length >= 8 ? load64(bytes, offset) : K0;

		}
	}
	if trailer {
		// Discard anything unsigned.
		req.Trailer = make(http.Header)
		trailers := req.Header.Values(awsTrailerHeader)
		for _, key := range trailers {
			req.Trailer.Add(key, "")
		}
	} else {
		req.Trailer = nil
	}
	return &s3UnsignedChunkedReader{
		trailers: req.Trailer,
		reader:   bufio.NewReader(req.Body),
		buffer:   make([]byte, 64*1024),
	}, ErrNone
}

				iamLogIf(ctx, err)
			} else if foundGroupDN == nil || !underBaseDN {
				return wrapSRErr(errNoSuchGroup)
			}
			entityName = foundGroupDN.NormDN
		} else {
			var foundUserDN *xldap.DNSearchResult
			if foundUserDN, err = globalIAMSys.LDAPConfig.GetValidatedDNForUsername(entityName); err != nil {
				iamLogIf(ctx, err)
			} else if foundUserDN == nil {
				return wrapSRErr(errNoSuchUser)

			t.Errorf("errors happened when query first: %v", err)
		} else {
			CheckUser(t, first, users[0])
		}
	})

	t.Run("Last", func(t *testing.T) {
		var last User
		if err := DB.Where("name = ?", "find").Last(&last).Error; err != nil {
			t.Errorf("errors happened when query last: %v", err)
		} else {
			CheckUser(t, last, users[2])
		}
	})

	var all []User

        if (expected == 0) {
          assertWithMessage(x + ", " + y).that(actual).isEqualTo(expected);
        } else if (expected < 0) {
          assertWithMessage(x + ", " + y + " (expected: " + expected + ", actual" + actual + ")")
              .that(actual < 0)
              .isTrue();
        } else {
          assertWithMessage(x + ", " + y + " (expected: " + expected + ", actual" + actual + ")")
              .that(actual > 0)

        int statusCode;
        if ((errcode & 0xC0000000) != 0) {
            statusCode = errcode;
        } else if (dosErrorCodeStatuses.containsKey(errcode)) {
            statusCode = dosErrorCodeStatuses.get(errcode);
        } else {
            statusCode = NT_STATUS_UNSUCCESSFUL;
        }
        return statusCode;
    }

	if bucketName == "" {
		if s3Error := checkRequestAuthType(ctx, r, policy.ListenNotificationAction, bucketName, ""); s3Error != ErrNone {
			writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL)
			return
		}
	} else {
		if s3Error := checkRequestAuthType(ctx, r, policy.ListenBucketNotificationAction, bucketName, ""); s3Error != ErrNone {
			writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL)
			return
		}
	}