#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <string>

namespace {
using std::cin;
using std::cout;
using std::int64_t;
using std::size_t;

namespace base {
template <typename T, size_t... sizes>
struct NestedArray {};

template <typename T, size_t size, size_t... sizes>
struct NestedArray<T, size, sizes...> {
  using Type = std::array<typename NestedArray<T, sizes...>::Type, size>;
};

template <typename T>
struct NestedArray<T> {
  using Type = T;
};

template <typename T, size_t... sizes>
using Array = typename NestedArray<T, sizes...>::Type;

void OptimizeIO() {
  std::ios::sync_with_stdio(false);
  cin.tie(nullptr), cout.tie(nullptr);
}

void OptimizeIO(const std::string &input_file, const std::string &output_file) {
  static std::ifstream input_stream(input_file);
  static std::ofstream output_stream(output_file);
  cin.rdbuf(input_stream.rdbuf());
  cout.rdbuf(output_stream.rdbuf());
  cin.tie(nullptr), cout.tie(nullptr);
}
}  // namespace base

using base::Array;

const int kMaxN = 1.0e5 + 5;
int n, tot;
int64_t ans;
Array<int, kMaxN> a, sum_a, raw, tmp, tr;

struct Node {
  int val, num;
};

Array<Node, kMaxN> b;

void Add(int x, int v) {
  while (x <= tot) tr[x] += v, x += x & -x;
}

int Sum(int x) {
  int ans = 0;
  while (x) ans += tr[x], x &= x - 1;
  return ans;
}

int Divide(int x, int y) { return x >= 0 ? x / y : (x - y + 1) / y; }

void Solve() {
  cin >> n;
  for (int i = 1; i <= n; i++) cin >> a[i];
  sum_a[0] = 0;
  for (int i = 1; i <= n; i++) sum_a[i] = sum_a[i - 1] + a[i];

  if (sum_a[n] < 0) {
    cout << "-1\n";
    return;
  }

  if (sum_a[n] == 0) {
    if (std::count(a.begin() + 1, a.begin() + n + 1, 0) == n) {
      cout << "0\n";
    } else {
      cout << "-1\n";
    }

    return;
  }

  ans = 0;
  std::copy_n(sum_a.begin(), n, raw.begin());
  std::sort(raw.begin(), raw.begin() + n);
  std::copy_n(raw.begin(), n, tmp.begin());
  tot = std::unique(raw.begin(), raw.begin() + n) - raw.begin();

  for (int i = 0; i < n; i++) {
    sum_a[i] = std::lower_bound(raw.begin(), raw.begin() + tot, sum_a[i]) -
               raw.begin() + 1;
  }

  for (int i = 0; i < n; i++) {
    ans += i - Sum(sum_a[i]);
    Add(sum_a[i], 1);
  }

  int m = 0;

  for (int i = 0; i < n;) {
    int j = i;
    while (j < n && tmp[j] == tmp[i]) j++;
    b[++m] = {tmp[i], j - i}, i = j;
  }

  std::fill_n(tr.begin() + 1, tot, 0);
  tot = 0;

  for (int i = 1; i <= m; i++) {
    int x = b[i].val + 1;
    x -= Divide(x, sum_a[n]) * sum_a[n];
    raw[++tot] = x;
  }

  std::sort(raw.begin() + 1, raw.begin() + tot + 1);
  tot = std::unique(raw.begin() + 1, raw.begin() + tot + 1) - raw.begin() - 1;
  int tot = 0;
  int64_t sum = 0;

  for (int i = 1; i <= m; i++) {
    int q = Divide(b[i].val, sum_a[n]);
    int r = b[i].val - q * sum_a[n];
    ans += static_cast<int64_t>(tot) * q - sum;
    sum += static_cast<int64_t>(b[i].num) * q;
    int qwq = std::lower_bound(raw.begin() + 1, raw.begin() + ::tot + 1, r) -
              raw.begin() - 1;
    ans -= static_cast<int64_t>(b[i].num) * (tot - Sum(qwq));
    r = (r + 1) % sum_a[n];
    qwq = std::lower_bound(raw.begin() + 1, raw.begin() + ::tot + 1, r) -
          raw.begin();
    Add(qwq, b[i].num);
    tot += b[i].num;
  }

  cout << ans << "\n";
  std::fill_n(tr.begin() + 1, ::tot, 0);
}

int Main() {
  base::OptimizeIO();
  int t;
  cin >> t;
  while (t--) Solve();
  return 0;
}
}  // namespace

int main() { return Main(); }