test/fuzz/call_graph_test.cpp - third_party/spirv-tools - Git at Google

 // Copyright (c) 2020 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "source/fuzz/call_graph.h"

 #include "gtest/gtest.h"
 #include "source/fuzz/fuzzer_util.h"
 #include "test/fuzz/fuzz_test_util.h"

 namespace spvtools {
 namespace fuzz {
 namespace {

 // The SPIR-V came from this GLSL, slightly modified
 // (main is %2, A is %35, B is %48, C is %50, D is %61):
 //
 //    #version 310 es
 //
 //    int A (int x) {
 //      return x + 1;
 //    }
 //
 //    void D() {
 //    }
 //
 //    void C() {
 //      int x = 0;
 //      int y = 0;
 //
 //      while (x < 10) {
 //        while (y < 10) {
 //          y = A(y);
 //        }
 //        x = A(x);
 //      }
 //    }
 //
 //    void B () {
 //      int x = 0;
 //      int y = 0;
 //
 //      while (x < 10) {
 //        D();
 //        while (y < 10) {
 //          y = A(y);
 //          C();
 //        }
 //        x++;
 //      }
 //
 //    }
 //
 //    void main()
 //    {
 //      int x = 0;
 //      int y = 0;
 //      int z = 0;
 //
 //      while (x < 10) {
 //        while(y < 10) {
 //          y = A(x);
 //          while (z < 10) {
 //            z = A(z);
 //          }
 //        }
 //        x += 2;
 //      }
 //
 //      B();
 //      C();
 //    }
 std::string shader = R"(
                OpCapability Shader
           %1 = OpExtInstImport "GLSL.std.450"
                OpMemoryModel Logical GLSL450
                OpEntryPoint Fragment %2 "main"
                OpExecutionMode %2 OriginUpperLeft
                OpSource ESSL 310
           %3 = OpTypeVoid
           %4 = OpTypeFunction %3
           %5 = OpTypeInt 32 1
           %6 = OpTypePointer Function %5
           %7 = OpTypeFunction %5 %6
           %8 = OpConstant %5 1
           %9 = OpConstant %5 0
          %10 = OpConstant %5 10
          %11 = OpTypeBool
          %12 = OpConstant %5 2
           %2 = OpFunction %3 None %4
          %13 = OpLabel
          %14 = OpVariable %6 Function
          %15 = OpVariable %6 Function
          %16 = OpVariable %6 Function
          %17 = OpVariable %6 Function
          %18 = OpVariable %6 Function
                OpStore %14 %9
                OpStore %15 %9
                OpStore %16 %9
                OpBranch %19
          %19 = OpLabel
                OpLoopMerge %20 %21 None
                OpBranch %22
          %22 = OpLabel
          %23 = OpLoad %5 %14
          %24 = OpSLessThan %11 %23 %10
                OpBranchConditional %24 %25 %20
          %25 = OpLabel
                OpBranch %26
          %26 = OpLabel
                OpLoopMerge %27 %28 None
                OpBranch %29
          %29 = OpLabel
          %30 = OpLoad %5 %15
          %31 = OpSLessThan %11 %30 %10
                OpBranchConditional %31 %32 %27
          %32 = OpLabel
          %33 = OpLoad %5 %14
                OpStore %17 %33
          %34 = OpFunctionCall %5 %35 %17
                OpStore %15 %34
                OpBranch %36
          %36 = OpLabel
                OpLoopMerge %37 %38 None
                OpBranch %39
          %39 = OpLabel
          %40 = OpLoad %5 %16
          %41 = OpSLessThan %11 %40 %10
                OpBranchConditional %41 %42 %37
          %42 = OpLabel
          %43 = OpLoad %5 %16
                OpStore %18 %43
          %44 = OpFunctionCall %5 %35 %18
                OpStore %16 %44
                OpBranch %38
          %38 = OpLabel
                OpBranch %36
          %37 = OpLabel
                OpBranch %28
          %28 = OpLabel
                OpBranch %26
          %27 = OpLabel
          %45 = OpLoad %5 %14
          %46 = OpIAdd %5 %45 %12
                OpStore %14 %46
                OpBranch %21
          %21 = OpLabel
                OpBranch %19
          %20 = OpLabel
          %47 = OpFunctionCall %3 %48
          %49 = OpFunctionCall %3 %50
                OpReturn
                OpFunctionEnd
          %35 = OpFunction %5 None %7
          %51 = OpFunctionParameter %6
          %52 = OpLabel
          %53 = OpLoad %5 %51
          %54 = OpIAdd %5 %53 %8
                OpReturnValue %54
                OpFunctionEnd
          %48 = OpFunction %3 None %4
          %55 = OpLabel
          %56 = OpVariable %6 Function
          %57 = OpVariable %6 Function
          %58 = OpVariable %6 Function
                OpStore %56 %9
                OpStore %57 %9
                OpBranch %59
          %59 = OpLabel
          %60 = OpFunctionCall %3 %61
                OpLoopMerge %62 %63 None
                OpBranch %64
          %64 = OpLabel
                OpLoopMerge %65 %66 None
                OpBranch %67
          %67 = OpLabel
          %68 = OpLoad %5 %57
          %69 = OpSLessThan %11 %68 %10
                OpBranchConditional %69 %70 %65
          %70 = OpLabel
          %71 = OpLoad %5 %57
                OpStore %58 %71
          %72 = OpFunctionCall %5 %35 %58
                OpStore %57 %72
          %73 = OpFunctionCall %3 %50
                OpBranch %66
          %66 = OpLabel
                OpBranch %64
          %65 = OpLabel
          %74 = OpLoad %5 %56
          %75 = OpIAdd %5 %74 %8
                OpStore %56 %75
                OpBranch %63
          %63 = OpLabel
          %76 = OpLoad %5 %56
          %77 = OpSLessThan %11 %76 %10
                OpBranchConditional %77 %59 %62
          %62 = OpLabel
                OpReturn
                OpFunctionEnd
          %50 = OpFunction %3 None %4
          %78 = OpLabel
          %79 = OpVariable %6 Function
          %80 = OpVariable %6 Function
          %81 = OpVariable %6 Function
          %82 = OpVariable %6 Function
                OpStore %79 %9
                OpStore %80 %9
                OpBranch %83
          %83 = OpLabel
                OpLoopMerge %84 %85 None
                OpBranch %86
          %86 = OpLabel
          %87 = OpLoad %5 %79
          %88 = OpSLessThan %11 %87 %10
                OpBranchConditional %88 %89 %84
          %89 = OpLabel
                OpBranch %90
          %90 = OpLabel
                OpLoopMerge %91 %92 None
                OpBranch %93
          %93 = OpLabel
          %94 = OpLoad %5 %80
          %95 = OpSLessThan %11 %94 %10
                OpBranchConditional %95 %96 %91
          %96 = OpLabel
          %97 = OpLoad %5 %80
                OpStore %81 %97
          %98 = OpFunctionCall %5 %35 %81
                OpStore %80 %98
                OpBranch %92
          %92 = OpLabel
                OpBranch %90
          %91 = OpLabel
          %99 = OpLoad %5 %79
                OpStore %82 %99
         %100 = OpFunctionCall %5 %35 %82
                OpStore %79 %100
                OpBranch %85
          %85 = OpLabel
                OpBranch %83
          %84 = OpLabel
                OpReturn
                OpFunctionEnd
          %61 = OpFunction %3 None %4
         %101 = OpLabel
                OpReturn
                OpFunctionEnd
 )";

 // We have that:
 // main calls:
 // - A (maximum loop nesting depth of function call: 3)
 // - B (0)
 // - C (0)
 // A calls nothing.
 // B calls:
 // - A (2)
 // - C (2)
 // - D (1)
 // C calls:
 // - A (2)
 // D calls nothing.

 TEST(CallGraphTest, FunctionInDegree) {
   const auto env = SPV_ENV_UNIVERSAL_1_5;
   const auto consumer = nullptr;

   const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
   spvtools::ValidatorOptions validator_options;
   ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
                                                kConsoleMessageConsumer));

   const auto graph = CallGraph(context.get());

   const auto& function_in_degree = graph.GetFunctionInDegree();
   // Check the in-degrees of, in order: main, A, B, C, D.
   ASSERT_EQ(function_in_degree.at(2), 0);
   ASSERT_EQ(function_in_degree.at(35), 3);
   ASSERT_EQ(function_in_degree.at(48), 1);
   ASSERT_EQ(function_in_degree.at(50), 2);
   ASSERT_EQ(function_in_degree.at(61), 1);
 }

 TEST(CallGraphTest, DirectCallees) {
   const auto env = SPV_ENV_UNIVERSAL_1_5;
   const auto consumer = nullptr;

   const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
   spvtools::ValidatorOptions validator_options;
   ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
                                                kConsoleMessageConsumer));

   const auto graph = CallGraph(context.get());

   // Check the callee sets of, in order: main, A, B, C, D.
   ASSERT_EQ(graph.GetDirectCallees(2), std::set<uint32_t>({35, 48, 50}));
   ASSERT_EQ(graph.GetDirectCallees(35), std::set<uint32_t>({}));
   ASSERT_EQ(graph.GetDirectCallees(48), std::set<uint32_t>({35, 50, 61}));
   ASSERT_EQ(graph.GetDirectCallees(50), std::set<uint32_t>({35}));
   ASSERT_EQ(graph.GetDirectCallees(61), std::set<uint32_t>({}));
 }

 TEST(CallGraphTest, IndirectCallees) {
   const auto env = SPV_ENV_UNIVERSAL_1_5;
   const auto consumer = nullptr;

   const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
   spvtools::ValidatorOptions validator_options;
   ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
                                                kConsoleMessageConsumer));

   const auto graph = CallGraph(context.get());

   // Check the callee sets of, in order: main, A, B, C, D.
   ASSERT_EQ(graph.GetIndirectCallees(2), std::set<uint32_t>({35, 48, 50, 61}));
   ASSERT_EQ(graph.GetDirectCallees(35), std::set<uint32_t>({}));
   ASSERT_EQ(graph.GetDirectCallees(48), std::set<uint32_t>({35, 50, 61}));
   ASSERT_EQ(graph.GetDirectCallees(50), std::set<uint32_t>({35}));
   ASSERT_EQ(graph.GetDirectCallees(61), std::set<uint32_t>({}));
 }

 TEST(CallGraphTest, TopologicalOrder) {
   const auto env = SPV_ENV_UNIVERSAL_1_5;
   const auto consumer = nullptr;

   const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
   spvtools::ValidatorOptions validator_options;
   ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
                                                kConsoleMessageConsumer));

   const auto graph = CallGraph(context.get());

   const auto& topological_ordering = graph.GetFunctionsInTopologicalOrder();

   // The possible topological orderings are:
   //  - main, B, D, C, A
   //  - main, B, C, D, A
   //  - main, B, C, A, D
   ASSERT_TRUE(
       topological_ordering == std::vector<uint32_t>({2, 48, 61, 50, 35}) ||
       topological_ordering == std::vector<uint32_t>({2, 48, 50, 61, 35}) ||
       topological_ordering == std::vector<uint32_t>({2, 48, 50, 35, 61}));
 }

 TEST(CallGraphTest, LoopNestingDepth) {
   const auto env = SPV_ENV_UNIVERSAL_1_5;
   const auto consumer = nullptr;

   const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
   spvtools::ValidatorOptions validator_options;
   ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
                                                kConsoleMessageConsumer));

   const auto graph = CallGraph(context.get());

   // Check the maximum loop nesting depth for function calls to, in order:
   // main, A, B, C, D
   ASSERT_EQ(graph.GetMaxCallNestingDepth(2), 0);
   ASSERT_EQ(graph.GetMaxCallNestingDepth(35), 4);
   ASSERT_EQ(graph.GetMaxCallNestingDepth(48), 0);
   ASSERT_EQ(graph.GetMaxCallNestingDepth(50), 2);
   ASSERT_EQ(graph.GetMaxCallNestingDepth(61), 1);
 }

 }  // namespace
 }  // namespace fuzz
 }  // namespace spvtools
	// Copyright (c) 2020 Google LLC
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "source/fuzz/call_graph.h"

	#include "gtest/gtest.h"
	#include "source/fuzz/fuzzer_util.h"
	#include "test/fuzz/fuzz_test_util.h"

	namespace spvtools {
	namespace fuzz {
	namespace {

	// The SPIR-V came from this GLSL, slightly modified
	// (main is %2, A is %35, B is %48, C is %50, D is %61):
	//
	// #version 310 es
	//
	// int A (int x) {
	// return x + 1;
	// }
	//
	// void D() {
	// }
	//
	// void C() {
	// int x = 0;
	// int y = 0;
	//
	// while (x < 10) {
	// while (y < 10) {
	// y = A(y);
	// }
	// x = A(x);
	// }
	// }
	//
	// void B () {
	// int x = 0;
	// int y = 0;
	//
	// while (x < 10) {
	// D();
	// while (y < 10) {
	// y = A(y);
	// C();
	// }
	// x++;
	// }
	//
	// }
	//
	// void main()
	// {
	// int x = 0;
	// int y = 0;
	// int z = 0;
	//
	// while (x < 10) {
	// while(y < 10) {
	// y = A(x);
	// while (z < 10) {
	// z = A(z);
	// }
	// }
	// x += 2;
	// }
	//
	// B();
	// C();
	// }
	std::string shader = R"(
	OpCapability Shader
	%1 = OpExtInstImport "GLSL.std.450"
	OpMemoryModel Logical GLSL450
	OpEntryPoint Fragment %2 "main"
	OpExecutionMode %2 OriginUpperLeft
	OpSource ESSL 310
	%3 = OpTypeVoid
	%4 = OpTypeFunction %3
	%5 = OpTypeInt 32 1
	%6 = OpTypePointer Function %5
	%7 = OpTypeFunction %5 %6
	%8 = OpConstant %5 1
	%9 = OpConstant %5 0
	%10 = OpConstant %5 10
	%11 = OpTypeBool
	%12 = OpConstant %5 2
	%2 = OpFunction %3 None %4
	%13 = OpLabel
	%14 = OpVariable %6 Function
	%15 = OpVariable %6 Function
	%16 = OpVariable %6 Function
	%17 = OpVariable %6 Function
	%18 = OpVariable %6 Function
	OpStore %14 %9
	OpStore %15 %9
	OpStore %16 %9
	OpBranch %19
	%19 = OpLabel
	OpLoopMerge %20 %21 None
	OpBranch %22
	%22 = OpLabel
	%23 = OpLoad %5 %14
	%24 = OpSLessThan %11 %23 %10
	OpBranchConditional %24 %25 %20
	%25 = OpLabel
	OpBranch %26
	%26 = OpLabel
	OpLoopMerge %27 %28 None
	OpBranch %29
	%29 = OpLabel
	%30 = OpLoad %5 %15
	%31 = OpSLessThan %11 %30 %10
	OpBranchConditional %31 %32 %27
	%32 = OpLabel
	%33 = OpLoad %5 %14
	OpStore %17 %33
	%34 = OpFunctionCall %5 %35 %17
	OpStore %15 %34
	OpBranch %36
	%36 = OpLabel
	OpLoopMerge %37 %38 None
	OpBranch %39
	%39 = OpLabel
	%40 = OpLoad %5 %16
	%41 = OpSLessThan %11 %40 %10
	OpBranchConditional %41 %42 %37
	%42 = OpLabel
	%43 = OpLoad %5 %16
	OpStore %18 %43
	%44 = OpFunctionCall %5 %35 %18
	OpStore %16 %44
	OpBranch %38
	%38 = OpLabel
	OpBranch %36
	%37 = OpLabel
	OpBranch %28
	%28 = OpLabel
	OpBranch %26
	%27 = OpLabel
	%45 = OpLoad %5 %14
	%46 = OpIAdd %5 %45 %12
	OpStore %14 %46
	OpBranch %21
	%21 = OpLabel
	OpBranch %19
	%20 = OpLabel
	%47 = OpFunctionCall %3 %48
	%49 = OpFunctionCall %3 %50
	OpReturn
	OpFunctionEnd
	%35 = OpFunction %5 None %7
	%51 = OpFunctionParameter %6
	%52 = OpLabel
	%53 = OpLoad %5 %51
	%54 = OpIAdd %5 %53 %8
	OpReturnValue %54
	OpFunctionEnd
	%48 = OpFunction %3 None %4
	%55 = OpLabel
	%56 = OpVariable %6 Function
	%57 = OpVariable %6 Function
	%58 = OpVariable %6 Function
	OpStore %56 %9
	OpStore %57 %9
	OpBranch %59
	%59 = OpLabel
	%60 = OpFunctionCall %3 %61
	OpLoopMerge %62 %63 None
	OpBranch %64
	%64 = OpLabel
	OpLoopMerge %65 %66 None
	OpBranch %67
	%67 = OpLabel
	%68 = OpLoad %5 %57
	%69 = OpSLessThan %11 %68 %10
	OpBranchConditional %69 %70 %65
	%70 = OpLabel
	%71 = OpLoad %5 %57
	OpStore %58 %71
	%72 = OpFunctionCall %5 %35 %58
	OpStore %57 %72
	%73 = OpFunctionCall %3 %50
	OpBranch %66
	%66 = OpLabel
	OpBranch %64
	%65 = OpLabel
	%74 = OpLoad %5 %56
	%75 = OpIAdd %5 %74 %8
	OpStore %56 %75
	OpBranch %63
	%63 = OpLabel
	%76 = OpLoad %5 %56
	%77 = OpSLessThan %11 %76 %10
	OpBranchConditional %77 %59 %62
	%62 = OpLabel
	OpReturn
	OpFunctionEnd
	%50 = OpFunction %3 None %4
	%78 = OpLabel
	%79 = OpVariable %6 Function
	%80 = OpVariable %6 Function
	%81 = OpVariable %6 Function
	%82 = OpVariable %6 Function
	OpStore %79 %9
	OpStore %80 %9
	OpBranch %83
	%83 = OpLabel
	OpLoopMerge %84 %85 None
	OpBranch %86
	%86 = OpLabel
	%87 = OpLoad %5 %79
	%88 = OpSLessThan %11 %87 %10
	OpBranchConditional %88 %89 %84
	%89 = OpLabel
	OpBranch %90
	%90 = OpLabel
	OpLoopMerge %91 %92 None
	OpBranch %93
	%93 = OpLabel
	%94 = OpLoad %5 %80
	%95 = OpSLessThan %11 %94 %10
	OpBranchConditional %95 %96 %91
	%96 = OpLabel
	%97 = OpLoad %5 %80
	OpStore %81 %97
	%98 = OpFunctionCall %5 %35 %81
	OpStore %80 %98
	OpBranch %92
	%92 = OpLabel
	OpBranch %90
	%91 = OpLabel
	%99 = OpLoad %5 %79
	OpStore %82 %99
	%100 = OpFunctionCall %5 %35 %82
	OpStore %79 %100
	OpBranch %85
	%85 = OpLabel
	OpBranch %83
	%84 = OpLabel
	OpReturn
	OpFunctionEnd
	%61 = OpFunction %3 None %4
	%101 = OpLabel
	OpReturn
	OpFunctionEnd
	)";

	// We have that:
	// main calls:
	// - A (maximum loop nesting depth of function call: 3)
	// - B (0)
	// - C (0)
	// A calls nothing.
	// B calls:
	// - A (2)
	// - C (2)
	// - D (1)
	// C calls:
	// - A (2)
	// D calls nothing.

	TEST(CallGraphTest, FunctionInDegree) {
	const auto env = SPV_ENV_UNIVERSAL_1_5;
	const auto consumer = nullptr;

	const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
	spvtools::ValidatorOptions validator_options;
	ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
	kConsoleMessageConsumer));

	const auto graph = CallGraph(context.get());

	const auto& function_in_degree = graph.GetFunctionInDegree();
	// Check the in-degrees of, in order: main, A, B, C, D.
	ASSERT_EQ(function_in_degree.at(2), 0);
	ASSERT_EQ(function_in_degree.at(35), 3);
	ASSERT_EQ(function_in_degree.at(48), 1);
	ASSERT_EQ(function_in_degree.at(50), 2);
	ASSERT_EQ(function_in_degree.at(61), 1);
	}

	TEST(CallGraphTest, DirectCallees) {
	const auto env = SPV_ENV_UNIVERSAL_1_5;
	const auto consumer = nullptr;

	const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
	spvtools::ValidatorOptions validator_options;
	ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
	kConsoleMessageConsumer));

	const auto graph = CallGraph(context.get());

	// Check the callee sets of, in order: main, A, B, C, D.
	ASSERT_EQ(graph.GetDirectCallees(2), std::set<uint32_t>({35, 48, 50}));
	ASSERT_EQ(graph.GetDirectCallees(35), std::set<uint32_t>({}));
	ASSERT_EQ(graph.GetDirectCallees(48), std::set<uint32_t>({35, 50, 61}));
	ASSERT_EQ(graph.GetDirectCallees(50), std::set<uint32_t>({35}));
	ASSERT_EQ(graph.GetDirectCallees(61), std::set<uint32_t>({}));
	}

	TEST(CallGraphTest, IndirectCallees) {
	const auto env = SPV_ENV_UNIVERSAL_1_5;
	const auto consumer = nullptr;

	const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
	spvtools::ValidatorOptions validator_options;
	ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
	kConsoleMessageConsumer));

	const auto graph = CallGraph(context.get());

	// Check the callee sets of, in order: main, A, B, C, D.
	ASSERT_EQ(graph.GetIndirectCallees(2), std::set<uint32_t>({35, 48, 50, 61}));
	ASSERT_EQ(graph.GetDirectCallees(35), std::set<uint32_t>({}));
	ASSERT_EQ(graph.GetDirectCallees(48), std::set<uint32_t>({35, 50, 61}));
	ASSERT_EQ(graph.GetDirectCallees(50), std::set<uint32_t>({35}));
	ASSERT_EQ(graph.GetDirectCallees(61), std::set<uint32_t>({}));
	}

	TEST(CallGraphTest, TopologicalOrder) {
	const auto env = SPV_ENV_UNIVERSAL_1_5;
	const auto consumer = nullptr;

	const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
	spvtools::ValidatorOptions validator_options;
	ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
	kConsoleMessageConsumer));

	const auto graph = CallGraph(context.get());

	const auto& topological_ordering = graph.GetFunctionsInTopologicalOrder();

	// The possible topological orderings are:
	// - main, B, D, C, A
	// - main, B, C, D, A
	// - main, B, C, A, D
	ASSERT_TRUE(
	topological_ordering == std::vector<uint32_t>({2, 48, 61, 50, 35}) \|\|
	topological_ordering == std::vector<uint32_t>({2, 48, 50, 61, 35}) \|\|
	topological_ordering == std::vector<uint32_t>({2, 48, 50, 35, 61}));
	}

	TEST(CallGraphTest, LoopNestingDepth) {
	const auto env = SPV_ENV_UNIVERSAL_1_5;
	const auto consumer = nullptr;

	const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
	spvtools::ValidatorOptions validator_options;
	ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
	kConsoleMessageConsumer));

	const auto graph = CallGraph(context.get());

	// Check the maximum loop nesting depth for function calls to, in order:
	// main, A, B, C, D
	ASSERT_EQ(graph.GetMaxCallNestingDepth(2), 0);
	ASSERT_EQ(graph.GetMaxCallNestingDepth(35), 4);
	ASSERT_EQ(graph.GetMaxCallNestingDepth(48), 0);
	ASSERT_EQ(graph.GetMaxCallNestingDepth(50), 2);
	ASSERT_EQ(graph.GetMaxCallNestingDepth(61), 1);
	}

	} // namespace
	} // namespace fuzz
	} // namespace spvtools