if compress:
        data = gzip.compress(data)
        headers["Content-Encoding"] = "gzip"
    headers["Content-Type"] = "application/json"
    response = client.post("/sum", content=data, headers=headers)
    assert response.json() == {"sum": n}


def test_request_class(client: TestClient):
    response = client.get("/check-class")

	iv := DB.Table(`table_invoices`).Select(`seller, SUM(total) as total, SUM(paid) as paid, SUM(balance) as balance`).Group(`seller`)
	stmt = dryDB.Table(`table_employees`).Select(`id, name, iv.total, iv.paid, iv.balance`).Joins(`LEFT JOIN (?) AS iv ON iv.seller = table_employees.id`, iv).Scan(&user).Statement

	_, err := hasher.Write(content)
	if err != nil {
		return err
	}
	sum := hasher.Sum(nil)
	if c.WantParts > 0 && c.WantParts != parts {
		return ChecksumMismatch{
			Want: fmt.Sprintf("%s-%d", c.Encoded, c.WantParts),
			Got:  fmt.Sprintf("%s-%d", base64.StdEncoding.EncodeToString(sum), parts),
		}
	}

	if !bytes.Equal(sum, c.Raw) {
		return ChecksumMismatch{
			Want: c.Encoded,

  public void removeAllZeros() {
    map.values().removeIf(x -> x == 0);
  }

  /**
   * Returns the sum of all values in this map.
   *
   * <p>This method is not atomic: the sum may or may not include other concurrent operations.
   */
  public long sum() {
    return map.values().stream().mapToLong(Long::longValue).sum();
  }

  @LazyInit private transient @Nullable Map<K, Long> asMap;

        for (int i = 0; i < elements.length; i++) {
          // add to either; sum should contain all
          if (i % 2 == 0) {
            multiset1.add(elements[i]);
          } else {
            multiset2.add(elements[i]);
          }
        }
        return sum(multiset1, multiset2);
      }
    };
  }

  private static TestStringMultisetGenerator differenceGenerator() {

	if n > 0 {
		c.h.Write(p[:n])
	}
	if errors.Is(err, io.EOF) {
		got := c.h.Sum(nil)
		if !bytes.Equal(got, c.want) {
			return n, ErrInvalidChecksum
		}
		return n, err
	}
	return n, err
}

// Close satisfies io.Closer
func (c Checker) Close() error {
	err := c.c.Close()
	if err == nil {
		got := c.h.Sum(nil)
		if !bytes.Equal(got, c.want) {
			return ErrInvalidChecksum
		}
	}
	return err

	}, {
		Expressions: []clause.Expression{
			clause.Eq{Column: clause.Expr{SQL: "SUM(?)", Vars: []interface{}{clause.Column{Name: "id"}}}, Value: 100},
		},
		ExpectedVars: []interface{}{100},
		Result:       "SUM(`id`) = ?",
	}, {
		Expressions: []clause.Expression{
			clause.Gte{Column: clause.Expr{SQL: "SUM(?)", Vars: []interface{}{clause.Column{Table: "users", Name: "id"}}}, Value: 100},
		},

  public void testHashCode() {
    int expectedHashCode = 0;
    for (Entry<K, V> entry : getSampleEntries()) {
      expectedHashCode += hash(entry);
    }
    assertEquals(
        "A Map's hashCode() should be the sum of those of its entries.",
        expectedHashCode,
        getMap().hashCode());
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  @MapFeature.Require(ALLOWS_NULL_KEYS)

    int expectedHashCode = 0;
    for (E element : getSampleElements()) {
      expectedHashCode += (element == null) ? 0 : element.hashCode();
    }
    assertEquals(
        "A Set's hashCode() should be the sum of those of its elements.",
        expectedHashCode,
        getSet().hashCode());
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  @CollectionFeature.Require(ALLOWS_NULL_VALUES)

    int expectedHashCode = 0;
    for (E element : getSampleElements()) {
      expectedHashCode += (element == null) ? 0 : element.hashCode();
    }
    assertEquals(
        "A Set's hashCode() should be the sum of those of its elements.",
        expectedHashCode,
        getSet().hashCode());
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  @CollectionFeature.Require(ALLOWS_NULL_VALUES)