Function assertQuery

Parameters

• name: string | TestLabel

  Name of the test case to generate
• parser: KnownParser

  R Shell Session/Parser to use
• code: string

  R code to execute the query on
• queries: readonly (
      | Queries
      | VirtualQueryArgumentsWithType<Queries["type"], VirtualArguments>
  )[]

  Queries to execute
• Optionalexpected:
      | OmitFromValues<Omit<QueryResults<Queries["type"]>, ".meta">, ".meta">
      | (
          info: PipelineOutput<
              | Pipeline<
                  | {
                      dependencies: readonly [];
                      description: "Parse the given R code into an AST";
                      executed: OncePerFile;
                      humanReadableName: "parse with R shell";
                      name: "parse";
                      printer: {
                          "0": <Input>(input: Input) => Input;
                          "2": {
                              (
                                  value: any,
                                  replacer?: (this: ..., key: ..., value: ...) => ...,
                                  space?: string | number,
                              ): string;
                              (
                                  value: any,
                                  replacer?: null | (...)[],
                                  space?: string | number,
                              ): string;
                          };
                          "5": (
                              __namedParameters: ParseStepOutput<string>,
                              config: QuadSerializationConfiguration,
                          ) => string;
                      };
                      processor: (
                          _results: unknown,
                          input: Partial<ParseRequiredInput<string>>,
                      ) => Promise<ParseStepOutput<string>>;
                      requiredInput: ParseRequiredInput<string>;
                  }
                  | {
                      dependencies: readonly ["parse"];
                      description: "Normalize the AST to flowR's AST";
                      executed: OncePerFile;
                      humanReadableName: "normalize";
                      name: "normalize";
                      printer: {
                          "0": <Input>(input: Input) => Input;
                          "2": (ast: NormalizedAst) => string;
                          "3": (ast: NormalizedAst) => string;
                          "4": (ast: NormalizedAst) => string;
                          "5": (
                              ast: NormalizedAst,
                              config: QuadSerializationConfiguration,
                          ) => string;
                      };
                      processor: (
                          results: { parse?: ParseStepOutput<(...)> },
                          input: Partial<NormalizeRequiredInput>,
                      ) => NormalizedAst<ParentInformation, RNode<ParentInformation>>;
                      requiredInput: NormalizeRequiredInput;
                  }
                  | {
                      dependencies: readonly ["normalize"];
                      description: "Construct the dataflow graph";
                      executed: OncePerFile;
                      humanReadableName: "dataflow";
                      name: "dataflow";
                      printer: {
                          "0": <Input>(input: Input) => Input;
                          "2": (df: DataflowInformation) => string;
                          "3": (df: DataflowInformation) => string;
                          "4": (df: DataflowInformation) => string;
                          "5": (
                              df: DataflowInformation,
                              config: QuadSerializationConfiguration,
                          ) => string;
                      };
                      processor: (
                          results: { normalize?: NormalizedAst<(...), (...)> },
                          input: { parser?: Parser<(...)>; request?: RParseRequests },
                          config: FlowrConfigOptions,
                      ) => DataflowInformation & { cfgQuick: (...) | (...) };
                      requiredInput: {};
                  },
              >
              | Pipeline<
                  | {
                      dependencies: readonly ["normalize"];
                      description: "Construct the dataflow graph";
                      executed: OncePerFile;
                      humanReadableName: "dataflow";
                      name: "dataflow";
                      printer: {
                          "0": <Input>(input: Input) => Input;
                          "2": (df: DataflowInformation) => string;
                          "3": (df: DataflowInformation) => string;
                          "4": (df: DataflowInformation) => string;
                          "5": (
                              df: DataflowInformation,
                              config: QuadSerializationConfiguration,
                          ) => string;
                      };
                      processor: (
                          results: { normalize?: NormalizedAst<(...), (...)> },
                          input: { parser?: Parser<(...)>; request?: RParseRequests },
                          config: FlowrConfigOptions,
                      ) => DataflowInformation & { cfgQuick: (...) | (...) };
                      requiredInput: {};
                  }
                  | {
                      dependencies: readonly [];
                      description: "Parse the given R code into an AST using tree-sitter";
                      executed: OncePerFile;
                      humanReadableName: "parse with tree-sitter";
                      name: "parse";
                      printer: {
                          "0": <Input>(input: Input) => Input;
                          "2": {
                              (
                                  value: any,
                                  replacer?: (this: ..., key: ..., value: ...) => ...,
                                  space?: string | number,
                              ): string;
                              (
                                  value: any,
                                  replacer?: null | (...)[],
                                  space?: string | number,
                              ): string;
                          };
                      };
                      processor: (
                          _results: unknown,
                          input: Partial<ParseRequiredInput<Tree>>,
                      ) => Promise<ParseStepOutput<Tree>>;
                      requiredInput: ParseRequiredInput<Tree>;
                  }
                  | {
                      dependencies: readonly ["parse"];
                      description: "Normalize the AST to flowR's AST";
                      executed: OncePerFile;
                      humanReadableName: "normalize tree-sitter tree";
                      name: "normalize";
                      printer: {
                          "0": <Input>(input: Input) => Input;
                          "2": (ast: NormalizedAst) => string;
                          "3": (ast: NormalizedAst) => string;
                          "4": (ast: NormalizedAst) => string;
                          "5": (
                              ast: NormalizedAst,
                              config: QuadSerializationConfiguration,
                          ) => string;
                      };
                      processor: (
                          results: { parse?: ParseStepOutputTS },
                          input: Partial<NormalizeRequiredInput>,
                          config: FlowrConfigOptions,
                      ) => NormalizedAst<ParentInformation, RNode<ParentInformation>>;
                      requiredInput: NormalizeRequiredInput;
                  },
              >,
          >,
      ) => | OmitFromValues<
          Omit<QueryResults<Queries["type"]>, ".meta">,
          ".meta",
      >
      | Promise<
          OmitFromValues<Omit<QueryResults<Queries["type"]>, ".meta">, ".meta">,
      >

  Expected result of the queries (without attached meta-information like timing), if this is empty, you just want to check that no exception has been thrown
• runFull: boolean = false

  Whether to run the full analysis beforehand