func TestLex(t *testing.T) {
	for _, test := range lexTests {
		input := NewInput(test.name)
		input.Push(NewTokenizer(test.name, strings.NewReader(test.input), nil))
		result := drain(input)
		if result != test.output {
			t.Errorf("%s: got %q expected %q", test.name, result, test.output)
		}
	}
}

// lines joins the arguments together as complete lines.
func lines(a ...string) string {
	return strings.Join(a, "\n") + "\n"

 *   <li>Finally, natural ordering is used (i.e. the result of {@code Bar.compareTo(Bar)} is
 *       returned)
 * </ol>
 *
 * <p>Alas, {@link #reverse} is a little different. As you read backwards through a chain and
 * encounter a call to {@code reverse}, continue working backwards until a result is determined, and
 * then reverse that result.
 *
 * <h3>Additional notes</h3>
 *

        @Override
        public boolean isExecutingNow() {
            return false;
        }

        @Override
        public <RESULT> OptionalThing<RESULT> mapExecutingNow(
                final java.util.function.Function<org.lastaflute.job.subsidiary.SnapshotExecState, RESULT> oneArgLambda) {
            return OptionalThing.empty();
        }

        @Override

     * The script data or code that was executed.
     * This field contains the actual script content that was run.
     */
    public String scriptData;

    /**
     * The result or output from the script execution.
     * This field contains any output or result data from the script.
     */
    public String scriptResult;

    /**
     * The timestamp when the job started execution.

			t.Fatalf("error: expected = <nil>, got = %v", err)
		}
		if testCase.expectedErr && err == nil {
			t.Fatalf("error: expected error, got = <nil>")
		}
		if err == nil && testCase.expectedResult != flag {
			t.Fatalf("result: expected: %v, got: %v", testCase.expectedResult, flag)
		}
	}
}

// Test ParseBoolFlag()
func TestParseBoolFlag(t *testing.T) {
	testCases := []struct {
		flagStr        string
		expectedResult BoolFlag

        ArtifactResolutionResult result = new ArtifactResolutionResult();

        if (request.isResolveRoot()) {
            try {
                resolve(request.getArtifact(), request);
                result.addArtifact(request.getArtifact());
            } catch (IOException e) {
                result.addMissingArtifact(request.getArtifact());
            }
        }

// all the ellipses sizes.
func getDivisibleSize(totalSizes []uint64) (result uint64) {
	gcd := func(x, y uint64) uint64 {
		for y != 0 {
			x, y = y, x%y
		}
		return x
	}
	result = totalSizes[0]
	for i := 1; i < len(totalSizes); i++ {
		result = gcd(result, totalSizes[i])
	}
	return result
}

// isValidSetSize - checks whether given count is a valid set size for erasure coding.

      TYPE_PRIORITY, TYPE_RST_STREAM, TYPE_GOAWAY, TYPE_WINDOW_UPDATE -> return BINARY[flags]
    }
    val result = if (flags < FLAGS.size) FLAGS[flags]!! else BINARY[flags]
    // Special case types that have overlap flag values.
    return when {
      type == TYPE_PUSH_PROMISE && flags and FLAG_END_PUSH_PROMISE != 0 -> {
        result.replace("HEADERS", "PUSH_PROMISE") // TODO: Avoid allocation.
      }

import org.apache.maven.execution.ProjectDependencyGraph;
import org.apache.maven.model.building.Result;

/**
 * Builds the {@link ProjectDependencyGraph inter-dependencies graph} between projects in the reactor.
 *
 * @since 3.0-alpha
 */
public interface GraphBuilder {
    String HINT = "graphBuilder";

    Result<? extends ProjectDependencyGraph> build(MavenSession session);

        ModelBuilderResult result = buildModel(session, src);
        Model model = result.getRawModel();
        return transformPom(model, project);
    }

    protected Model buildBomWithoutFlatten(RepositorySystemSession session, MavenProject project, ModelSource src)
            throws ModelBuilderException {
        ModelBuilderResult result = buildModel(session, src);