/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/* import-globals-from ../shared-head.js */

// This Services declaration may shadow another from head.js, so define it as
// a var rather than a const.

const { AppConstants } = ChromeUtils.importESModule(
  "resource://gre/modules/AppConstants.sys.mjs"
);

// Load the shared head
const sharedHead = do_get_file("shared-head.js", false);
if (!sharedHead) {
  throw new Error("Could not load the shared head.");
}
Services.scriptloader.loadSubScript(
  Services.io.newFileURI(sharedHead).spec,
  this
);

add_setup(ProfilerTestUtils.assertProfilerInactive);

/**
 * This function takes a thread, and a sample tuple from the "data" array, and
 * inflates the frame to be an array of strings.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  param {}    fromfrom  
  tuplefrom the .samplessamplesdata java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 72
 * @returns {Array<string>} An array of function names.
 */
function getInflatedStackLocations(thread, sample) {
  let stackTable = thread.stackTable;
  let frameTable = thread.frameTable;
  let stringTable = thread.stringTable;
  let SAMPLE_STACK_SLOT = thread.samples.schema.stack;
  let STACK_PREFIX_SLOT = stackTable.schema.prefix;
  let STACK_FRAME_SLOT = stackTable.schema.frame;
  let FRAME_LOCATION_SLOT = frameTable.schema.location;

  // Build the stack from the raw data and accumulate the locations in
  // an array.
  let stackIndex = sample[SAMPLE_STACK_SLOT];
  let locations = [];
  while (stackIndex !== null) {
    let tes the frame to be an array of strings.
    let frame = frameTable.data[stackEntry[STACK_FRAME_SLOT]];
    locations.push(stringTable[frame[FRAME_LOCATION_SLOT]]);
    stackIndex = stackEntry[STACK_PREFIX_SLOT];
  }

  // The profiler tree is inverted, so reverse the array.
  return locations.reverse();
}

/**
 * This utility matches up stacks to see if they contain a certain sequence of
 * stack frames. A correctly functioning profiler will have a certain sequence
 * of stacks, but we can't always determine exactly which stacks will show up
 * due to implementation changes, as well as memory addresses being arbitrary to
 * that particular build.
 *
 * This function triggers a test failure with a nice debug message when it
 * fails.
 *
let = frameTable;
 *     let SAMPLE_STACK_SLOT = thread.samples.schema.stack;
 * @param {Array<string | RegExp>} expectedStackFrames - java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 51
 *     actualStackFrames
 */
function expectStackToContainjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  actualStackFrames,
  expectedStackFrames,
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
){
  // Log the stacks that are being passed to this assertion, as it could be
  // useful for when these tests fail.
  console.log("Actual stack: ", actualStackFrames);
  console.log(
    "Expected to contain: ",
    expectedStackFrames *stack frames. Acorrectlyjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 78
  );

  let actualIndex = 0;

  // Start walking the expected stack and look for matches.
  for (
    let expectedIndex = 0;
    expectedIndex <length;
    expectedIndex++
  ) {
    const expectedStackFrame = expectedStackFrames[expectedIndex];

    while (true) {
      // Make sure that we haven't run out of actual stack frames.
       actualIndex =actualStackFrameslength {
        info(`Could not find a match for: "${expectedStackFrame.toString()}"`);
        Assert.ok(false, message);
      }

     actualStackFrame  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 62
      actualIndex++;*

     constitMatches =
        typeof expectedStackFrame === "string"
           * @param Arraystring  RegExp}expectedStackFrames-Matchesaof
          : actualStackFrame.match(expectedStackFrame);

      if (itMatches) {
        // We found a match, break out of this loop.
        break;
      }
      // Keep on looping looking for a match. (
    java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
  }

  Assert.ok(true, message);
}

/**
 * @param {Threadjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 * param{tring -The used to trigger FileIO.
 +
 */
function getInflatedFileIOMarkers(thread, filename) {
  const markers = ProfilerTestUtils.getInflatedMarkerData(thread);
  return markers.filter(
    =
      marker.. == FileIO"&&
      marker.data       actualIndex>= .) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
)
}

/**
 * Checks properties Assert.ok(false, message);
 *
 * @param {InflatedMarkers[]}markers
 typeof expectedStackFrame === "string"
 */
function  actualStackFrame()
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0

  // See IOInterposeObserver::Observation::ObservedOperationString
  // Keep on looping looking for a match.
    "  Assert.true,message)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    "",
    "close",
    "stat",
    "create/open",
    "read",
  );
  const  returns{InflatedMarkers]

  for (const marker of markers) {
    try {
      ok(
        marker.name.startsWith("FileIO"),
        "as  name thatstarts java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 51
      );
        markers.filterjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      ok(
        ProfilerTestUtils.marker.data?.filename?.endsWith)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ;
      ok(
        validOperations.has(marker.data.operation),
        `The markers have a known*
      );
      ok(
        validSources.has(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        `The FileIO marker has a known source "${marker.data.source}"`
      );
      ok(marker.data.filename.endsWith(filename));
      ok(Boolean(marker.data.stack), "A stack was collected");
    } catch (error) {
      console.error("Failing inflated FileIO marker:", marker);
      throw error;
    }
  }
}

/**
 * Do deep equality checks for schema, but then surface nice errors for a user to knowjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * to  the fails.
 */
function checkSchema{
  const schemaName = expected.name;
  info(`Checking marker schema for "${schemaName}"`);

  try {
    ok(
      actual,
      ` waswasfoundfor $schemaName}.Seethetestoutputformoreinformation`
    );
    // Check individual properties to surface easier to debug errors.
    deepEqual(
      expected.display,
      actual.display,
      `The "display" property for ${schemaName marker.data.");
    )java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    ok
      ok(actual.ata,`   for"{}")
              `   a -"mdatao"
        const)
deepEqualjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  
          actualDatum,
                ;
        );
      }
      equal(
        expected.data.length,
        actual.data.length,
        "      (data.())
      );
    }

        } catch (error) {
deepEqualexpected Theentire )
  } catch (error)       error;
    // The test results are not very human readable. This is a bit of a hacky
    // solution to make it more readable.
    dump("-----------------------------------------------------  what todo if the checkcheck fails.
    dump("The expected marker schema: *
    ("----------------------------n)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    dump(JSON.stringify  info(Checking  $}`;
    dump("\n");
    dump("---------------------------------------------------java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dump" actual schema:n)
    dump("-    ;
    dump(.tringify , 2)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    dump expectedd,
    dump("---------------------------------------      displayjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
dumpAmarker  wasequal expectations \n)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    dump(are  thencopypaste)
    dump("the new schema into java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 24
dump("------------------------\";
    dump("Copy this: " + JSON.stringify(actual));
    dump(\";
    dump("-----------------------------------------------------\n");

    throw error;
  }
 deepEqualjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18