} else if (expectNew) {
            assertNotNull(renewed, "renew() should return a new non-null instance");
            assertNotSame(impl, renewed, "renew() should return a different instance");
            assertTrue(renewed instanceof SmbRenewableCredentials, "renewed credentials should still be SmbRenewableCredentials");
        } else {

			fmt.Printf("%s %s\n", sessionID, fmt.Sprintf(format, v...))
		} else {
			fmt.Printf(format+"\n", v...)
		}
	}
}

// PrintCommand implement Logger
func (log *minioLogger) PrintCommand(sessionID string, command string, params string) {
	if serverDebugLog {
		if command == "PASS" {
			fmt.Printf("%s > PASS ****\n", sessionID)
		} else {
			fmt.Printf("%s > %s %s\n", sessionID, command, params)
		}
	}
}

      if (newSize > mask) {
        // Resize and add new entry
        mask = resizeTable(mask, CompactHashing.newCapacity(mask), hash, newEntryIndex);
      } else {
        CompactHashing.tableSet(requireTable(), tableIndex, newEntryIndex + 1);
      }
    } else {
      int entryIndex;
      int entry;
      int hashPrefix = CompactHashing.getHashPrefix(hash, mask);
      int bucketLength = 0;
      do {

        this.traceResource = this.session.getConfig().isTraceResourceUsage();
        if (this.traceResource) {
            this.acquires = new LinkedList<>();
            this.releases = new LinkedList<>();
        } else {
            this.acquires = null;
            this.releases = null;
        }
    }

    boolean matches(final String shr, final String servc) {

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

                    continue;
                }
                collect.addDependency(RepositoryUtils.toDependency(dependency, stereotypes));
            }
        } else {
            Map<String, Dependency> dependencies = new HashMap<>();
            for (Dependency dependency : project.getDependencies()) {
                String classifier = dependency.getClassifier();

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

	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
		}
	}

                .map { "$it.*" } + "" +
                AnnotationGenerator.ADDITIONAL_DEFAULT_IMPORTS
        return imports.joinToString(separator = "\n") {
            if (it.isBlank()) "" else "import $it"
        }
    }

    private
    inline fun <reified Receiver> groovyReceiverAccessors(): String {
        return groovyReceiverAccessors(Receiver::class)
    }

    private

      @SuppressWarnings("unchecked")
      List<T> result = (List<T>) reversed;
      return result;
    } else if (list instanceof ReverseList) {
      return ((ReverseList<T>) list).getForwardList();
    } else if (list instanceof RandomAccess) {
      return new RandomAccessReverseList<>(list);
    } else {
      return new ReverseList<>(list);
    }
  }