java
import java.util.*;
import java.lang.*;
import java.io.*;

class Codechef {

    // We will implement the logic as follows:
    //
    // 1) If there is only 1 peak (N=1), no pairs can form, answer = 0.
    // 2) Otherwise, build an array S of length N-1 where
    //       S[i] = +1 if H[i+1] > H[i], or -1 if H[i+1] < H[i].
    //    (Note that the problem guarantees |H[i+1] - H[i]| = 1, so no 0-differences.)
    //
    // 3) We then break this S array into "runs" of consecutive +1s or -1s.  Each run
    //    in S corresponds to a strictly-monotonic subarray in H.  Concretely, we scan
    //    S from left to right and cut a new run whenever the sign changes from +1 to -1
    //    or from -1 to +1.
    //
    //    Example: H = [3, 4, 5, 4, 3]
    //      S = [+1, +1, -1, -1]
    //      This breaks into two runs in terms of indices in S:
    //         run1: [0..1] => covers H indices [0..2]  (3 -> 4 -> 5)
    //         run2: [2..3] => covers H indices [2..4]  (5 -> 4 -> 3)
    //
    // 4) For each run r that covers a segment [startH..endH] of H (inclusive),
    //    let size = (endH - startH + 1).  All peaks in that run can pairwise meet
    //    (since within a strictly monotonic segment, you never repeat a height).
    //    Therefore the number of "internal" friendships contributed by that run is
    //        size * (size - 1) / 2
    //
    // 5) Adjacent runs in S share exactly one boundary index in H.  Let that boundary
    //    index be b.  If run r1 covers [a..b], run r2 covers [b..c], and r1 is strictly
    //    increasing while r2 is strictly decreasing (or vice versa), then any peak i
    //    in r1 and peak j in r2 can meet at b (because i->...->b is strictly monotonic,
    //    and j->...->b is strictly monotonic, with one sign-change at b).
    //    We must, however, be careful to exclude pairs that are already counted
    //    in the runs themselves (notably those involving b in both runs).
    //
    //    It turns out the correct count of new "cross-run" pairs introduced by
    //    that shared boundary b is:
    //        (size(r1) - 1) * (size(r2) - 1).
    //
    //    Explanation sketch:
    //      - run r1 has size(r1) indices, all of which include b.
    //      - run r2 has size(r2) indices, also including b.
    //      - The "full cross product" size(r1)*size(r2) counts (b,b) (not a pair),
    //        and pairs (b,x) or (x,b) which are already in an internal run's count.
    //      - After carefully excluding those duplicates, the net new count is
    //          (size(r1)-1) * (size(r2)-1).
    //
    // 6) Summing (a) all intra-run pairs plus (b) the cross-run pairs for each boundary
    //    gives the total number of friendships.
    //
    // Complexity: O(N) per test.  Since the problem constraints say the sum of N over
    // all testcases is at most 2*10^5, this will run efficiently.

    public static void main(String[] args) throws java.lang.Exception {
        FastIO in = new FastIO();
        int T = in.nextInt();
        StringBuilder sb = new StringBuilder();

        // We will process each test in O(N), building the "runs" of +1 or -1 in S.
        // Then we add up the internal pairs plus cross-run pairs.

        while (T-- > 0) {
            int N = in.nextInt();
            int[] H = new int[N];
            for (int i = 0; i < N; i++) {
                H[i] = in.nextInt();
            }

            // If there is only one peak, no pairs can form
            if (N == 1) {
                sb.append(0).append('\n');
                continue;
            }

            // Build the sign array S of length N-1
            int[] S = new int[N-1];
            for (int i = 0; i < N - 1; i++) {
                if (H[i+1] > H[i]) {
                    S[i] = 1;
                } else {
                    S[i] = -1;
                }
            }

            // Identify consecutive runs in S
            ArrayList<int[]> runs = new ArrayList<>();
            // Each element in 'runs' will be an int[2] = {startInS, endInS}
            // meaning the run covers S indices [startInS..endInS], inclusive.

            int start = 0;
            int sign = S[0];
            for (int i = 1; i < N - 1; i++) {
                if (S[i] != sign) {
                    // We close the previous run [start.. i-1]
                    runs.add(new int[]{start, i - 1});
                    // Start a new run at i
                    start = i;
                    sign = S[i];
                }
            }
            // Add the final run from 'start' to N-2
            runs.add(new int[]{start, N - 2});

            // Now 'runs' covers the entire array S in consecutive monotonic segments.
            // Each run [a..b] in S coverage corresponds to H coverage [a..(b+1)].
            // The size of that run in H is (b - a + 2).

            long totalFriendships = 0;
            long[] runSizes = new long[runs.size()];

            // 1) Sum of internal pairs
            for (int i = 0; i < runs.size(); i++) {
                int[] r = runs.get(i);
                int a = r[0], b = r[1];
                long size = (b - a + 2);  // number of H-indices in this run
                runSizes[i] = size;
                // number of internal pairs is size * (size - 1) / 2
                totalFriendships += size * (size - 1) / 2;
            }

            // 2) Sum of cross-run pairs between adjacent runs
            //    If runs i and i+1 share a boundary in H at index = (runs[i].end + 1)
            //    Then cross-run = (runSizes[i] - 1) * (runSizes[i+1] - 1).
            for (int i = 0; i + 1 < runs.size(); i++) {
                // We'll verify the boundary is consecutive in H.  In terms of S coverage:
                //   run i => covers [a..b] in S => H coverage [a.. b+1]
                //   run i+1 => covers [c..d] in S => H coverage [c.. d+1]
                // They share boundary if (b+1 == c).  We'll check that just to be safe.
                int[] r1 = runs.get(i);
                int[] r2 = runs.get(i + 1);
                // H-end for run r1 is (r1[1] + 1)
                // H-start for run r2 is r2[0]
                if (r1[1] + 1 == r2[0]) {
                    long cross = (runSizes[i] - 1) * (runSizes[i + 1] - 1);
                    totalFriendships += cross;
                }
                // Else, no shared boundary => no cross-run pairs.
            }

            sb.append(totalFriendships).append('\n');
        }

        System.out.print(sb);
    }

    // A simple fast IO helper (Scanner can be slow for large input).
    static class FastIO {
        private BufferedReader br;
        private StringTokenizer st;

        public FastIO() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }
    }
}

Explanation of the core ideas:

• Because adjacent heights differ by exactly 1, any path that changes “direction” (from going up to going down or vice versa) would necessarily revisit a height. Hence a person’s movements must lie entirely in a strictly-increasing or strictly-decreasing subarray of the heights.

• We find these maximal strictly-monotonic “runs” by scanning the sign array S (where S[i] = ±1 depending on whether H[i+1] > H[i] or H[i+1] < H[i]).

• Within each run, all persons on those peaks can meet each other (they form an internal complete sub-group).

• Additionally, at each boundary between an “up” run and a “down” run (or vice versa), everyone from one run can meet everyone from the neighboring run at the boundary index (so that adds (size(run1) - 1) × (size(run2) - 1) new friendships).

• Summing these internal and cross-run contributions yields the answer.