s = file.getAbsolutePath();
        } else {
            // an ordinary relative path, align with project directory
            s = new File(new File(basedir, s).toURI().normalize()).getAbsolutePath();
        }

        return s;
    }

    private String stripBasedirToken(String s) {
        if (s != null) {

        graph = new Graph();

        // groupId:artifactId:version -> project
        projectMap = new HashMap<>(projects.size() * 2);

        // groupId:artifactId -> (version -> vertex)
        Map<String, Map<String, Vertex>> vertexMap = new HashMap<>(projects.size() * 2);

        for (MavenProject project : projects) {

                classifier,
                new TransformedArtifactHandler(
                        classifier, extension, source.getArtifactHandler().getPackaging()));
        this.pomArtifactTransformer = pomArtifactTransformer;
        this.project = project;
        this.target = target;
        this.session = session;
        this.sourcePathProvider = sourcePathProvider;
        this.sourceState = new AtomicReference<>(null);
    }

			if disk == OfflineDisk {
				continue
			}
			if !disk.IsOnline() {
				continue
			}
			diskMap[disk.Endpoint()] = disk
		}
	}
	return diskMap
}

// Initializes a new StorageAPI from the endpoint argument, returns
// StorageAPI and also `format` which exists on the disk.
func connectEndpoint(endpoint Endpoint) (StorageAPI, *formatErasureV3, error) {

		}
	}
}

func TestGetNewCredentials(t *testing.T) {
	cred, err := GetNewCredentials()
	if err != nil {
		t.Fatalf("Failed to get a new credential")
	}
	if !cred.IsValid() {
		t.Fatalf("Failed to get new valid credential")
	}
	if len(cred.AccessKey) != accessKeyMaxLen {
		t.Fatalf("access key length: expected: %v, got: %v", secretKeyMaxLen, len(cred.AccessKey))
	}

        assertTrue(range.containsVersion(new DefaultArtifactVersion("1.1-SNAPSHOT")));
        assertTrue(range.containsVersion(new DefaultArtifactVersion("1.2-SNAPSHOT")));

        range = VersionRange.createFromVersionSpec("[1.0-SNAPSHOT,1.2]");

        assertTrue(range.containsVersion(new DefaultArtifactVersion("1.0-SNAPSHOT")));
        assertTrue(range.containsVersion(new DefaultArtifactVersion("1.1-SNAPSHOT")));
    }

				}
				*z.SmallerThan, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "SmallerThan")
					return
				}
			}
		case "SkipErrs":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "SkipErrs")
					return
				}
				z.SkipErrs = nil
			} else {
				if z.SkipErrs == nil {
					z.SkipErrs = new(bool)
				}

        Set<ApiChange> seenApiChanges = (Set<ApiChange>) context.getUserData().get("seenApiChanges");
        Set<ApiChange> left = new HashSet<>(acceptedApiChanges);
        left.removeAll(seenApiChanges);
        if (!left.isEmpty()) {
            String formattedLeft = CollectionUtils.join("\n", left);
            throw new RuntimeException("The following regressions are declared as accepted, but didn't match any rule:\n\n" + formattedLeft);
        }

                    && recorder.hasReachedMaxLevel()) {
                event.getSession()
                        .getResult()
                        .addException(
                                new Exception("Build failed due to log statements with a higher severity than allowed. "
                                        + "Fix the logged issues or remove flag --fail-on-severity (-fos)."));
            }

	return shuffleWithDist[StorageAPI](disks, distribution)
}

// evalDisks - returns a new slice of disks where nil is set if
// the corresponding error in errs slice is not nil
func evalDisks(disks []StorageAPI, errs []error) []StorageAPI {
	if len(errs) != len(disks) {
		bugLogIf(GlobalContext, errors.New("unexpected drives/errors slice length"))
		return nil
	}
	newDisks := make([]StorageAPI, len(disks))