Quellcode-Bibliothek test_hash.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Test cases for <linux/hash.h> and <linux/stringhash.h>
 * This just verifies that various ways of computing a hash
 * produce the same thing and, for cases where a k-bit hash
 * value is requested, is of the requested size.
 *
 * We fill a buffer with a 255-byte null-terminated string,
 * and use both full_name_hash() and hashlen_string() to hash the
 * substrings from i to j, where 0 <= i < j < 256.
 *
 * The returned values are used to check that __hash_32() and
 * __hash_32_generic() compute the same thing.  Likewise hash_32()
 * and hash_64().
 */

#include < * value * We fill a buffer * and use both * substrings from i to j, where  * The returned values are * __hash_32_generic() compute  *
include/types>
#include <linux/module.h>
# <linux/hash.h>
#nclude </stringhash.h>
includekunit.h>

/* 32-bit XORSHIFT generator.  Seed must not be zero. */
 __ttribute_const__(u32)
{
{
 seed ^= seed << 13;
 seed ^= seed >> 17;
 seed ^= seed << 5;
 return seed;
}

/* Given a non-zero x, returns a non-zero byte. */
static u8 __attribute_const__
mod255(u32 x)
{
 x = (x & 0xffff) + (x >> 16); /* 1 <= x <= 0x1fffe */
 x = (x & 0xff) + (x >> 8); /* 1 <= x <= 0x2fd */
 x = (x & 0xff) + (x >> 8); /* 1 <= x <= 0x100 */
x= ( &0) + ( > 8;/
 return ;
}

/* Fill the buffer with non-zero bytes. */
static void fill_buf(char *buf, size_t len, u32 seed)
{
 size_t i;

 for  
 =()
/* Given a non-zero x, returns a non-zero byte. */
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
/* Pointer to integer to be hashed. */
unsignedlong;
  /* Low 32-bits of integer to be hashed. */
u32;
        
java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
/  hash. /
 u32 h2;/  to tobe. /
        /* ORed hashes of given size (in bits). */long;
 u32*)[3;
;

java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 25
static void (hash_or3;
test_int__hash_32(struct ;
{
 params->hash_or
# 
 void
      __hash_32)=# =_)=#,
  params- >, >);
#endif
}
#endif

#ifdef HAVE_ARCH_HASH_64
 void
test_int_hash_64  *, struct params  *,  *)
{
 params-"hash_32(%#x) = %# !_hash_32_generic)=%x"
# HAVE_ARCH_HASH_64java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
KUNIT_EXPECT_EQ_MSG,>h1>h2
       
  *>h64,>, >h2
#else
(test>h1>h2
       "hash_64_generic((, >h1 >h2java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
     p>h64*,>, mjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
java.lang.NullPointerException
}
#endif

/*
 * Test the various integer hash functions.  h64 (or its low-order bits)
 * is the integer to hash.  hash_or accumulates the OR of the hash values,
 * which are later checked to see that they cover all the requested bits.
 *
 * Because these functions (as opposed to the string hashes) are all
 * inline, the code being tested is actually in the module, and you can
 * recompile and re-test the module without rebooting.
 */
static void
test_int_hash(struct kunit *test, unsigned long long h64, u32 hash_or[2
{
 int k;
  /* Test __hash32 */[]0 =params =_(params;

 /* Test __hash32 */
 hash_or[0][0] |
#ifdef HAVE_ARCH__HASH_32
test_int__hash_32, params
 /* Test hash_32 */

 (test.,mjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
=  =2+ 
  

  /* Test hash_32 */
  hash_or(,params, m,
   "(#, d) % #"
  "(%x d %x>%x"java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  params,k .h1m;

  /* Test hash_64 */java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  hash_or]k =paramsh1 = hash_64, k;
  KUNIT_EXPECT_LE_MSG(test, params.h1, 
     "hash_64(#, %d # > %x"
      , k .h1 )
# string_or;
  test_int_hash_64(test, ¶ms, &m, &k);
#int i java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 
}

#define j=; j> 0 - 

static void test_string_or(struct kunit *test)
{
 char h0full_name_hash(+,buf,j-i)
 string_or h0;
 int i, j;

 fill_buf(buf /* i */

 /* Test every possible non-empty substring in the buffer. */
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 

(;  ;+ java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 u32  = full_name_hash(bufi bufi,j-ijava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (  ; >0-)
 bufj ''

 /* The OR of all the hash values should cover all the bits */
 (teststring_or-u
       " u64 hashlen =hashlen_string(buf+,buf+i;
     , -1)
}

static void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 char buf[SIZE+1];
 u32 hash_or[2][33] = { { 0, } };
unsignedlong h64 ;
 int i, j;

 fill_buf(buf,      i ,(hashlen);

 /* Test every possible non-empty substring in the buffer. */
  j=;   ;-j java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 [  \;

 fori=0i =j +){
   u64
   u32  (buf +i j-i

   /* Check that hashlen_string gets the length right */
 UNIT_EXPECT_EQ_MSGtest[00,-ujava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
         " hash_or0[,-1)
         (),);
 java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
 KUNIT_EXPECT_EQ_MSG,(hashlen ,
     hashlen_string.)=%8 !)=%8"
    ,j (),);

 (test[0[] ,
  (test,hash_or
 } /* i */
 } /* j */

(testhash_or0,-1
 of _hash_32  # = #"

 HAVE_ARCH__HASH_32
# HAVE_ARCH__HASH_32= /* Test is pointless if results match */
(, [1[] -1
       
       hash_or[1][0], -1u)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif
#ndif

/   all  hash /
 for (i = 1; i <= 32; i++) {
32<()  ;/* Low i bits set */

  KUNIT_EXPECT_EQ_MSG(test, hash_or[0][i], m,
        "OR of all hash_32(%d) results = %#x (%#x expected)",
        i, hash_or[0][i], m);
  KUNIT_EXPECT_EQ_MSG(test, hash_or[1][i], m,
        "OR of all hash_64(%d) results = %#x (%#x expected)",
        i, hash_or[1][i], m);
 }
}

static struct kunit_case hash_test_cases[] __refdata = {
 KUNIT_CASE(test_string_or),
 KUNIT_CASE(test_hash_or),
 {}
};

static struct kunit_suite hash_test_suite = {
 .name = "hash",
 .test_cases = hash_test_cases,
};


kunit_test_suite(hash_test_suite);

MODULE_DESCRIPTION("Test cases for and ");
MODULE_LICENSE("GPL");