t.Errorf("Should got error with invalid SQL")
	}

	var count1, count2 int64
	DB.Model(&User{}).Count(&count1)
	if count1 <= 0 {
		t.Errorf("Should find some users")
	}

	if DB.Where("name = ?", "jinzhu; delete * from users").First(&User{}).Error == nil {
		t.Errorf("Should got error with invalid SQL")
	}

	DB.Model(&User{}).Count(&count2)
	if count1 != count2 {
		t.Errorf("No user should not be deleted by invalid SQL")
	}

    }

    /**
     * Test validation of excessive negotiate context count.
     */
    @Test
    public void testExcessiveNegotiateContextCount() {
        byte[] buffer = createBasicNegotiateResponseBuffer();
        // Set SMB 3.1.1 dialect
        SMBUtil.writeInt2(0x0311, buffer, 4);
        // Set excessive negotiate context count (should be limited to 100)
        SMBUtil.writeInt2(1000, buffer, 6);

        assertNotNull(securityDescriptor.getOwnerGroupSid());
    }

    @Test
    @DisplayName("Test decode throws exception for invalid ACE count")
    void testDecodeThrowsExceptionForInvalidAceCount() {
        // Prepare buffer with invalid ACE count (> 4096)
        prepareSecurityDescriptorBufferWithInvalidAceCount(testBuffer, 0);

labels.searchlog_log_type_search_keyword=Keyword Count
labels.searchlog_log_type_search_zerohit=Zero Hit Count
labels.searchlog_log_type_search_zeroclick=Zero Click Count
labels.searchlog_log_type_search_count_hour=Search Count/Hour
labels.searchlog_log_type_search_count_day=Search Count/Day
labels.searchlog_log_type_search_user_hour=User Count/Hour
labels.searchlog_log_type_search_user_day=User Count/Day

		*GetUser("slice-hasone-3", Config{Account: true}),
	}

	DB.Create(&users)

	// Count
	AssertAssociationCount(t, users, "Account", 2, "")

	// Find
	var accounts []Account
	if DB.Model(&users).Association("Account").Find(&accounts); len(accounts) != 2 {
		t.Errorf("accounts count should be %v, but got %v", 3, len(accounts))
	}

	// Append
	DB.Model(&users).Association("Account").Append(

				if err != nil {
					err = msgp.WrapError(err, "Curr")
					return
				}
				switch msgp.UnsafeString(field) {
				case "Count":
					z.Curr.Count, err = dc.ReadFloat64()
					if err != nil {
						err = msgp.WrapError(err, "Curr", "Count")
						return
					}
				case "Bytes":
					z.Curr.Bytes, err = dc.ReadFloat64()
					if err != nil {
						err = msgp.WrapError(err, "Curr", "Bytes")

  }

  private LinkedHashMultiset() {
    super(new LinkedHashMap<E, Count>());
  }

  private LinkedHashMultiset(int distinctElements) {
    super(Maps.newLinkedHashMapWithExpectedSize(distinctElements));
  }

  /**
   * @serialData the number of distinct elements, the first element, its count, the second element,
   *     its count, and so on
   */
  @GwtIncompatible
  @J2ktIncompatible

		Avg:  a.Avg,
		Max:  a.Max,
	}
	return w
}

// QStat holds queue stats for replication
type QStat struct {
	Count float64 `json:"count"`
	Bytes float64 `json:"bytes"`
}

func (q *QStat) add(o QStat) QStat {
	return QStat{Bytes: q.Bytes + o.Bytes, Count: q.Count + o.Count}
}

// InQueueMetric holds queue stats for replication
type InQueueMetric struct {
	Curr QStat `json:"curr" msg:"cq"`

         * The number of shares in the array.
         */
        public int count;
        /**
         * Array of ShareInfo0 structures containing share information.
         */
        public ShareInfo0[] array;

        @Override
        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(count);
            _dst.enc_ndr_referent(array, 1);

internal fun checkOffsetAndCount(
  arrayLength: Long,
  offset: Long,
  count: Long,
) {
  if (offset or count < 0L || offset > arrayLength || arrayLength - offset < count) {
    throw ArrayIndexOutOfBoundsException("length=$arrayLength, offset=$offset, count=$offset")
  }
}

internal fun <T> interleave(
  a: Iterable<T>,
  b: Iterable<T>,
): List<T> {