import hudson.matrix.MatrixBuild; //导入依赖的package包/类
/** Test artifact copy between matrix jobs, for artifact from matching axis */
@Test
public void testMatrixToMatrix() throws Exception {
    MatrixProject other = createMatrixArtifactProject(),
                  p = createMatrixProject();
    p.setAxes(new AxisList(new Axis("FOO", "one", "two"))); // should match other job
    p.getBuildersList().add(CopyArtifactUtil.createRunSelector(other.getName() + "/FOO=$FOO", null,
            new StatusRunSelector(StatusRunSelector.BuildStatus.STABLE), "", "", false, false, true));
    rule.assertBuildStatusSuccess(other.scheduleBuild2(0, new UserCause()).get());
    MatrixBuild b = p.scheduleBuild2(0, new UserCause()).get();
    rule.assertBuildStatusSuccess(b);
    MatrixRun r = b.getRun(new Combination(Collections.singletonMap("FOO", "one")));
    assertFile(true, "one.txt", r);
    assertFile(false, "two.txt", r);
    r = b.getRun(new Combination(Collections.singletonMap("FOO", "two")));
    assertFile(false, "one.txt", r);
    assertFile(true, "two.txt", r);
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
@Nonnull
public File getPollingLogFile() {
    File pollingFile;
    if (nonNull(job)) {
        pollingFile = job.getRootDir();
    } else if (run instanceof MatrixRun) {
        MatrixRun matrixRun = (MatrixRun) run;
        pollingFile = matrixRun.getParentBuild().getRootDir();
    } else if (run instanceof MatrixBuild) {
        pollingFile = run.getRootDir();
    } else if (nonNull(run)) {
        pollingFile = run.getRootDir();
    } else {
        throw new IllegalStateException("Can't get polling log file: no run or job initialised");
    }

    return new File(pollingFile, getPollingFileName());
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
@Test
public void matrixProjectTest() throws IOException, InterruptedException, ExecutionException {
    EnvVars env;
    MatrixProject p = jenkins.jenkins.createProject(MatrixProject.class, "matrixbuild");
    GitLabWebHookCause cause = new GitLabWebHookCause(generateCauseData());
    // set up 2x2 matrix
    AxisList axes = new AxisList();
    axes.add(new TextAxis("db","mysql","oracle"));
    axes.add(new TextAxis("direction","north","south"));
    p.setAxes(axes);

    MatrixBuild build = p.scheduleBuild2(0, cause).get();
    List<MatrixRun> runs = build.getRuns();
    assertEquals(4,runs.size());
    for (MatrixRun run : runs) {
        env = run.getEnvironment(listener);
        assertNotNull(env.get("db"));
        assertEnv(env);
    }
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
private void initPython() {
	if (pexec == null) {
		pexec = new PythonExecutor(this);
		String[] jMethods = new String[1];
		jMethods[0] = "doBuildConfiguration";
		String[] pFuncs = new String[1];
		pFuncs[0] = "do_build_configuration";
		Class[][] argTypes = new Class[1][];
		argTypes[0] = new Class[2];
		argTypes[0][0] = MatrixBuild.class;
		argTypes[0][1] = MatrixConfiguration.class;
		pexec.checkAbstrMethods(jMethods, pFuncs, argTypes);
		String[] functions = new String[0];
		int[] argsCount = new int[0];
		pexec.registerFunctions(functions, argsCount);
	}
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
/**
 * matrix-project requires special extraction.
 */
@CheckForNull
public static <T extends Cause> T ghCauseFromRun(Run<?, ?> run, Class<T> tClass) {
    if (run instanceof MatrixRun) {
        MatrixBuild parentBuild = ((MatrixRun) run).getParentBuild();
        if (nonNull(parentBuild)) {
            return parentBuild.getCause(tClass);
        }
    } else {
        return run.getCause(tClass);
    }

    return null;
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
@Test
public void testChildStatuses() throws Exception {
    final MatrixProject matrixProject = jRule.jenkins.createProject(MatrixProject.class, "matrix-project");

    matrixProject.addProperty(getPreconfiguredProperty(ghRule.getGhRepo()));
    matrixProject.addTrigger(getPreconfiguredPRTrigger());

    matrixProject.getBuildersList().add(new GitHubPRStatusBuilder());
    matrixProject.getBuildersList().add(new Shell("sleep 10"));

    matrixProject.getPublishersList().add(new GitHubPRBuildStatusPublisher());
    matrixProject.getPublishersList().add(new GitHubPRCommentPublisher(new GitHubPRMessage("Comment"), null, null));

    matrixProject.setAxes(
            new AxisList(
                    new TextAxis("first_axis", "first_value1", "first_value2"),
                    new TextAxis("second_axis", "sec_value1", "sec_value2")
            )
    );

    matrixProject.save();

    super.basicTest(matrixProject);

    for (MatrixBuild build : matrixProject.getBuilds()) {
        for (MatrixRun matrixRun : build.getRuns()) {
            jRule.assertLogNotContains("\tat", matrixRun);
        }
    }
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
@Test
public void shouldReturnDefaultManager() throws Exception {
    // GIVEN
    MatrixProject project = jenkinsRule.createMatrixProject("PRJ");

    GhprcBuildManager buildManager = GhprcBuildManagerFactoryUtil.getBuildManager(new MatrixBuild(project));

    // THEN
    assertThat(buildManager).isInstanceOf(GhprcDefaultBuildManager.class);
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
@Override
public MatrixAggregator createAggregator(final MatrixBuild matrixBuild, Launcher launcher, final BuildListener buildListener) {
    return new MatrixAggregator(matrixBuild, launcher, buildListener) {
        @Override
        public boolean endBuild() throws InterruptedException, IOException {
            return !executeOn.matrix() || _perform(matrixBuild, launcher, buildListener);
        }
    };
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
public MatrixAggregator createAggregator(MatrixBuild build, Launcher launcher, BuildListener listener) {
    return new MatrixAggregator(build, launcher, listener) {
        @Override
        public boolean endBuild() throws InterruptedException, IOException {
            perform(build, launcher, listener);
            return super.endBuild();
        }
    };
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
@Override
public void buildEnvironmentFor(@Nonnull Run r, @Nonnull EnvVars envs, @Nonnull TaskListener listener) throws IOException, InterruptedException {
    GitLabWebHookCause cause = null;
    if (r instanceof MatrixRun) {
        MatrixBuild parent = ((MatrixRun)r).getParentBuild();
        if (parent != null) {
            cause = (GitLabWebHookCause) parent.getCause(GitLabWebHookCause.class);
        }
    } else {
        cause = (GitLabWebHookCause) r.getCause(GitLabWebHookCause.class);
    }
    if (cause != null) {
        envs.overrideAll(cause.getData().getBuildVariables());
    }
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
static <T  extends Notifier & MatrixAggregatable> void verifyMatrixAggregatable(Class<T> publisherClass, BuildListener listener) throws InterruptedException, IOException {
    AbstractBuild build = mock(AbstractBuild.class);
    AbstractProject project = mock(MatrixConfiguration.class);
    Notifier publisher = mock(publisherClass);
    MatrixBuild parentBuild = mock(MatrixBuild.class);

    when(build.getParent()).thenReturn(project);
    when(((MatrixAggregatable) publisher).createAggregator(any(MatrixBuild.class), any(Launcher.class), any(BuildListener.class))).thenCallRealMethod();
    when(publisher.perform(any(AbstractBuild.class), any(Launcher.class), any(BuildListener.class))).thenReturn(true);

    MatrixAggregator aggregator = ((MatrixAggregatable) publisher).createAggregator(parentBuild, null, listener);
    aggregator.startBuild();
    aggregator.endBuild();
    verify(publisher).perform(parentBuild, null, listener);
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
public MatrixAggregator createAggregator(MatrixBuild build, Launcher launcher, BuildListener listener) {
  return new MatrixAggregator(build, launcher, listener) {
    @Override
    public boolean endBuild() throws InterruptedException, IOException {
      return notifyReviewboard(listener, this.build);
    }
  };
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
/**
 * Inlined from {@link MatrixProject#setAxes(hudson.matrix.AxisList)} except it doesn't call save.
 *
 * @param matrixProject The project to set the Axis on.
 * @param axisList      The Axis list to set.
 */
private static void fixAxisList(MatrixProject matrixProject, AxisList axisList) {
    if (axisList == null) {
        return; //The "axes" field can never be null. So just to be extra careful.
    }
    ReflectionUtils.setFieldValue(MatrixProject.class, matrixProject, "axes", axisList);

    //noinspection unchecked
    ReflectionUtils.invokeMethod(MatrixProject.class, matrixProject, "rebuildConfigurations", ReflectionUtils.MethodParameter.get(MatrixBuild.MatrixBuildExecution.class, null));
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
@Test
@RandomlyFails(value = "No idea why matrix doesn't work normally")
public void testAbortRunningMatrixProject() throws Exception {

    MockFolder folder = j.createFolder("Matrix_folder");

    MatrixProject job1 = folder.createProject(MatrixProject.class, "project1");
    job1.setDisplayName("project1 display name");
    job1.setConcurrentBuild(true);
    job1.getBuildersList().add(new SleepBuilder());
    job1.setAxes(
            new AxisList(
                    new TextAxis("first_axis", "first_value1"),
                    new TextAxis("second_axis", "sec_value1")
            )
    );
    configRoundTripUnsecure(job1);
    job1.save();

    MatrixProject job2 = folder.createProject(MatrixProject.class, "project2");
    job2.setDisplayName("project1 display name");
    job2.setConcurrentBuild(true);
    job2.getBuildersList().add(new SleepBuilder());
    job2.setAxes(
            new AxisList(
                    new TextAxis("first_axis", "first_value1"),
                    new TextAxis("second_axis", "sec_value1")
            )
    );
    configRoundTripUnsecure(job2);
    job2.save();

    MatrixProject job3 = folder.createProject(MatrixProject.class, "project3");
    job3.setDisplayName("project1 display name");
    job3.setConcurrentBuild(true);
    job3.getBuildersList().add(new SleepBuilder());
    job3.setAxes(
            new AxisList(
                    new TextAxis("first_axis", "first_value1"),
                    new TextAxis("second_axis", "sec_value1")
            )
    );
    configRoundTripUnsecure(job3);
    job3.save();

    testAbortRunning(job1, job2, job3);

    assertThat(job1.getBuilds(), hasSize(3));

    for (MatrixBuild matrixBuild : job1.getBuilds()) {
        assertThat(matrixBuild.getResult(), is(Result.ABORTED));
        assertThat(matrixBuild.getRuns(), not(empty()));
        for (MatrixRun matrixRun : matrixBuild.getRuns()) {
            assertThat(matrixRun.getResult(), is(Result.ABORTED));
        }
    }
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
@Test
public void shouldCalculateUrlFromDefault() throws Exception {
    // GIVEN
    MatrixProject project = givenThatGhprcHasBeenTriggeredForAMatrixProject();

    // THEN
    assertThat(project.getBuilds().toArray().length).isEqualTo(1);

    MatrixBuild matrixBuild = project.getBuilds().getFirstBuild();

    GhprcBuildManager buildManager = GhprcBuildManagerFactoryUtil.getBuildManager(matrixBuild);

    assertThat(buildManager).isInstanceOf(GhprcDefaultBuildManager.class);

    assertThat(buildManager.calculateBuildUrl("defaultPublishedURL")).isEqualTo("defaultPublishedURL/" + matrixBuild.getUrl());
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
@Nonnull
@Override
protected BranchProjectFactory<MatrixProject, MatrixBuild> newProjectFactory() {
    return new MatrixBranchProjectFactory();
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
@Override
public boolean doBuildConfiguration(MatrixBuild b, MatrixConfiguration c) {
	initPython();
	return pexec.execPythonBool("do_build_configuration", b, c);
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public MatrixAggregator createAggregator(final MatrixBuild build, final Launcher launcher,
                                         final BuildListener listener) {
    return new DependencyCheckAnnotationsAggregator(build, launcher, listener, this, getDefaultEncoding(), usePreviousBuildAsReference(), useOnlyStableBuildsAsReference());
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
/** {@inheritDoc} */
public MatrixAggregator createAggregator(final MatrixBuild build, final Launcher launcher,
        final BuildListener listener) {
    return new CheckStyleAnnotationsAggregator(build, launcher, listener, this, getDefaultEncoding(), useOnlyStableBuildsAsReference());
}
 

import hudson.matrix.MatrixBuild; //导入依赖的package包/类
/**
 * Creates a new instance of {@link DependencyCheckAnnotationsAggregator}.
 *
 * @param build
 *            the matrix build
 * @param launcher
 *            the launcher
 * @param listener
 *            the build listener
 * @param healthDescriptor
 *            health descriptor
 * @param defaultEncoding
 *            the default encoding to be used when reading and parsing files
 * @param usePreviousBuildAsReference
 *            determines whether the previous build should be used as the
 *            reference build
 * @param useStableBuildAsReference
 *            determines whether only stable builds should be used as
 *            reference builds or not
 */
public DependencyCheckAnnotationsAggregator(final MatrixBuild build, final Launcher launcher,
                                            final BuildListener listener, final HealthDescriptor healthDescriptor, final String defaultEncoding,
                                            final boolean usePreviousBuildAsReference, final boolean useStableBuildAsReference) {
    super(build, launcher, listener, healthDescriptor, defaultEncoding, usePreviousBuildAsReference, useStableBuildAsReference);
}