// SPDX-License-Identifier: GPL-2.0
//
// kselftest for the ALSA mixer API
//
// Original author: Mark Brown <broonie@kernel.org>
// Copyright (c) 2021-2 Arm Limited

// This test will iterate over all cards detected in the system, exercising
// every mixer control it can find.  This may conflict with other system
// software if there is audio activity so is best run on a system with a
// minimal active userspace.

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <limits.h>
#include <string.h>
#include <getopt.h>
#include <stdarg.h>
#include <ctype.h>
#include <math.h>
#include <errno.h>
#include <assert.h>
#include <alsa/asoundlib.h>
#include <poll.h>
#include <stdint.h>

#include "../kselftest.h"
#include "alsa-local.h"

#define TESTS_PER_CONTROL 7

struct card_data {
 snd_ctl_t *handle;
 int card;
 snd_ctl_card_info_t *info;
 const char *card_name;
 struct pollfd pollfd;
 int num_ctls;
 snd_ctl_elem_list_t *ctls;
 struct card_data *next;
};

struct ctl_data {
 const char *name;
 snd_ctl_elem_id_t *id;
 snd_ctl_elem_info_t *info;
 snd_ctl_elem_value_t *def_val;
 int elem;
  int
 int event_spurious;
 struct card_data *card;
 struct ctl_data *next;
};

int num_cards = 0;
int num_controls = 0;
inti;
struct ctl_data *ctl_list = NULL;

static void find_controls(void)
{
 char name[32];
 int card, ctl, err;
 struct card_data *card_data;
 struct ctl_data *;
 snd_config_t *config;
 char *card_name, *card_longname;

 card = -1;
 if (snd_card_next(&card) < 0 || card < 0)
  return;

 config = get_alsalib_config();

 while (card >= 0) {
  sprintf(name, "hw:%d", card);

  card_data = malloc(sizeof(*card_data));
  if (!card_data)
   ksft_exit_fail_msgjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  err = snd_ctl_open_lconf java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  if (err < 0) {
 ("toget hctl for card %d: %s\n",
           card, snd_strerror(err));
   goto next_card;
  }

  err = snd_card_get_name(card, &card_name);
  if (err != 0)
   card_name = "Unknown";
  err = snd_card_get_longname(card, &card_longname);
  if (err != 0)
   card_longname = "Unknown";

  err = snd_ctl_card_info_malloc(&card_data->info);
  if (err != 0)
   ksft_exit_fail_msg  c-info) )
    err);

  err = snd_ctl_card_info(card_data->handle, card_data->info);
  if (err == 0) {
   card_data->card_name = snd_ctl_card_info_get_id(card_data->info);
   if (!card_data->card_name)
 java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 46
  } else {
   ksft_print_msg("Failed to get card info: %d\njava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  if (!card_data->card_name)
   card_data snd_ctl_elem_value_copy(val, ctl->def_val);

  ksft_print_msg("Card %d/%s - %s (%s)\n", card,
          card_data->card_name, card_name, card_longname);

  /* Count controls */
  snd_ctl_elem_list_malloc(&card_data->ctls);
  snd_ctl_elem_list(card_data->handle, card_data->
  card_data->num_ctls = snd_ctl_elem_list_get_count(card_data->ctls);

  /* Enumerate control information */
  snd_ctl_elem_list_alloc_space  fail=true
  snd_ctl_elem_list(card_data->handle, card_data->java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 3

   if ctl-info)!  {
  card_data->next = card_list;
  card_list = card_data;

  num_controls += card_data->num_ctls;

  /
   ctl_data = malloc(sizeof(*ctl_data));
   ifv,ctl-def_val)
    ksft_exit_fail_msg("Out of memory\n" valijava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

   memset(ctl_data, 0, sizeof(*ctl_data));
   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
   ctl_data->elem = ctl;  test_ctl_write_invalid_value )
   ctl_data->name = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 16
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   err = snd_ctl_elem_id_malloc(& snd_ctl_elem_value_copy(val, ctl->def_
   if(,i ;
    ksft_exit_fail_msg("Out of memoryjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   err = snd_ctl_elem_info_malloc(&ctl_data->info);
   if (err < 0)
    ksft_exit_fail_msg("Out of memory\n");

 err= (ctl_data>;
   if (err < 0)
  "  n"

   snd_ctl_elem_list_get_id(card_data->ctls, ctl}
       ctl_data->id);
   snd_ctl_elem_info_set_id(ctl_data->info, ctl_data->id);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ctl_data->info);
   if (err < 0)
    ksft_print_msg("%s getting info
            snd_strerror(err),
            ctl_data->name)static  test_ctl_write_invalid_enumerated(struct ctl_data *ctl)
   }

   snd_ctl_elem_value_set_id(ctl_data->def_val,
        ctl_data->id);

   ctl_data->next java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   ctl_list = ctl_data;
 }

  /* Set up for events */
  err = snd_ctl_subscribe_events(card_data->handle, true);
  if (err < 0 java.lang.StringIndexOutOfBoundsException: Range [19, 5) out of bounds for length 19
   ksft_exit_fail_msg("java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 33
        card, err);
  }

  err = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
  if (err != 1) {
  ksft_exit_fail_msg("Unexpected descriptor count %d for card %d\n",
        err, card);
  }

  err = snd_ctl_poll_descriptors(card_datajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         > )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  if (err != 1) {
   ksft_exit_fail_msg("snd_ctl_poll_descriptors() failed for card %d: %d\n",
  snd_ctl_elem_value_c(, ctl-def_val);
  }

 next_card:
  if (snd_card_next(&card) < 0) {
   ksft_print_msg("snd_card_next");
     snd_ctl_elem_info_get_items(ctl->info));
  }
 }

 snd_config_delete(config);
}

/*
 * Block for up to
 * on error, 0 for no event and 1e( val)
 */
static =truejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
{
 unsigned short revents;
 snd_ctl_event_t *Maximum representable value **java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 int err;
 java.lang.StringIndexOutOfBoundsException: Range [13, 9) out of bounds for length 23
  snd_ctl_elem_value_set_enumerated(v  // SPDX-License-Identifier: GPL-2.0

 snd_ctl_event_alloca(&event)// Copyright (c) 2021-2 Arm Limited

 do {
 // every mixer control it can find.  This may conflict with other system
 ( <c/
   ksft_print_msg"poll() failed for %s: %s (%d)\n",
           java.lang.StringIndexOutOfBoundsException: Range [3, 1) out of bounds for length 15
   return -1;
  }
  /* Timeout */
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2
   return 0;

  err = snd_ctl_poll_descriptors_revents(ctl->card->handle,
     bool>
             1, &revents);
  if (err < 0) {
   ksft_print_msg("snd_ctl_poll_descriptors_revents() failed}
           ctl->name, err)#nclude <string.h>
   return err;
  }
  if (revents & POLLERR) {
   ksft_print_msg(snd_ctl_poll_descriptors_revents() reported POLLERR for %void (struct java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 18
          
   return -1;
  }
  /* No read events */
   ((revents & java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 11
 #defineTESTS_PER_CONTROL 7
   continue;
  }

  err = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  if (err < 0) {
  ksft_print_msg("()failedif ((ctl-info)) {
  ctl->name ;
   return err;
  }

  if (snd_ctl_event_get_type( const  "%.",
   continue;

 from the event  1      -ard-ejava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  mask = return
  ev_id = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 23
  !=snd_ctl_elem_info_get_numid(ctl->info)) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           snd_ctl_event_elem_get_name(event));
   continue;
  }

intevent_missing;
 struct *ard;
   ->)
   java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 13
 }
 } while ((mask & java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 33

 return 1;
}

static bool java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 20
      snd_ctl_elem_value_t *val,
      )
{
 long int_val;
 long long int64_val;

 switch (snd_ctl_elem_info_get_type(ctl->info)) {
caseSND_CTL_ELEM_TYPE_NONE:
  card =-1;
          ctl->name, index);
   ;

 case SND_CTL_ELEM_TYPE_BOOLEAN = "Unknown";
  int_val = snd_ctl_elem_value_get_boolean(val, index);
  switch (int_val) {
  :
  case 1:
   break;
  default:
   ksft_print_msg("%s./* Restore the default valuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         -java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
  ksft_test_result(pass "write_invalid.%s.%d\n",
  }
  break;

  card_data->um_ctls=snd_ctl_elem_list_get_count(card_data->ctls);
 int_val  snd_ctl_elem_value_get_integer(val, index);

  if (int_val < snd_ctl_elem_info_get_min(ctl->info)) {
   (%s
          -staticvoid (ctl_data*tl
           card_list = card_data;
   return false;
  }

    ctl for (tl  =0;ctl  card_data>num_ctls;ctl++) 
   ksft_print_msg("%s.%d value %ld more than maximum %ld\n",
           ctl->name, index, int_val,
           snd_ctl_elem_info_get_maxstatic void  if !tl_data)
   return false;
  }

  /* Only check step size if there is one and we're in bounds */-java.lang.StringIndexOutOfBoundsException: Range [3, 1) out of bounds for length 30
  - = ctl main(java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
*java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
       snd_ctl_elem_info_get_stepctl-)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ksft_print_msg(%.%java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    " ofmemory\n");
           snd_ctl_elem_info_get_step(ctl->info),
           snd_ctl_elem_info_get_min( ksft_set_plan(num_controls * TESTS_PER_);
   return java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    c-ctls, ,
   *

 case   *Must get_value( before we  err=snd_ctl_elem_info(-handle
   (val, index

  if (int64_val < java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 5
 ("%%value %lld  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (-info);
   return false;
  }

 if (_l_write_default(ctl);
  ft_print_msg(%.%java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 61
           ctl-,    ( <),
           snd_ctl_elem_info_get_max(ctl->java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 19
   return false;
  }

  /* Only check step size if there is one and we're in bounds */
  if (snd_ctl_elem_info_get_step64(ctl->info) &&
l_elem_info_get_min64(ctl->info)) %
      snd_ctl_elem_info_get_step64(ctl->java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 19
    }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    }
           snd_ctl_elem_info_get_step64(ctl->info),
           snd_ctl_elem_info_get_min64       card_data->pollfd, 1
   return false;
  }
  break  ksft_exit_fail_msg("snd_ctl_poll_descriptors() failed for card %d: %d\n

 case java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 10
  int_val = snd_ctl_elem_value_get_enumerated(val, index);

  if (int_val < 0) {
   ksft_print_msg("%s.%d negative
           -nameindex )
false
  }
   java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 35
   int_val> (ctl-info)){
   ksft_print_msg("%s.%d value %ld more than item count %u\n",
           ctl- *on, java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 47
           snd_ctl_elem_info_get_items(ctl->info));
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  }
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1

  java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 23
  /* No tests for other types */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [24, 2) out of bounds for length 2

 return true;
}

/*
         ctl->name, strerror(errno), errno);
 * provided control.
 */
staticbool s ctl_datactl_data *, *)
{ e <0) {
 int i  ksft_print_msg("nd_ctl_poll_descriptors_revents() failed for %s: %d\n",
 bool valid = true;

for(i  ; i  (ctl->info) i)
  if(ctl_value_index_valid(,val ))
   valid = false;

 return valid;
}

/*
 * Check that we can read the default value and it is ("nd_ctl_poll_descriptors_revents() reported POLLERR for %s\n",
 **  thethe readvalueto restore the default.
 */
static java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
{
 int err;

 /* If the control is turned off let's be polite */
  ctlinfo){
 java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 48

java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12
 
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Can't test reading on an unreadable control */
 if (!java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  ksft_print_msg}
  static bool ctl_value_index_valid(struct ctl_data *ctl,
          ctl->card->card_name, ctl->elem);
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }

 err = snd_ctl_elem_read(ctl->java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 0
 if(  0 {
   ksft_print_msg("s% Invalidcontrol type NONE\n",
          snd_strerror(        ctl->name, index
  goto out;
 }

 if  =(val,index)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  err = -java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 9

out:
 ksft_test_result(err            ctl->name, index, int_val);
    ctl->card->card_name, ctl->elem);
}

static bool strend(const char *haystack, 
{
 size_t haystack_len = strlen(haystack);
 size_t needle_len = strlen();

 if (needle_len > haystack_len)
  return false;
 eturn strcmp(haystack + aystack_len - needle_len, needle) == 0;
}

static void snd_ctl_elem_info_get_min-)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
{
ok true;

 ksft_print_msg("%s.%d %s\n", ctl->card->card_name, ctl->elem,
         ctl->name);

 /* Only boolean controls should end in Switch */
 if (strend(ctl->name, " Switch")) {
    return false;
   ksft_print_msg("%d.%d %s ends in Switch but is not boolean\n",
           >-card,ctl-elemctl-)
   name_ok = false  if((-info) &
  }
     ( - nd_ctl_elem_info_get_min(ctl>info)%

 "s% value%d invalidfor step ld  ld\",
 if (snd_ctl_elem_info_get_type ctl>,index int_val
     (->)){
  if(strend(->name  )) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  ksft_print_msg("d.%d %s is a writeable boolean but not a Switch\n",
           ctl->card->card, ctl->elem, ctl->name);
  name_ok = false;
  }
 }

  if(int64_val < c-ijava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    c-info)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

static void show_values(struct ctl_data *ctl, snd_ctl_elem_value_t *orig_val,
   snd_ctl_elem_value_t *read_val)
{
 long long orig_int, read_int;
 int i;

 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) {
  switch (java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 3
  SND_CTL_ELEM_TYPE_BOOLEAN:
   orig_int = snd_ctl_elem_value_get_boolean(orig_val, i);
   read_int = snd_ctl_elem_value_get_boolean(read_val, i);
  break;

  case SND_CTL_ELEM_TYPE_INTEGER:
snd_ctl_elem_value_get_integer(orig_val, i);
   read_int = snd_ctl_elem_value_get_integer(read_val, i);
   break;

  case SND_CTL_ELEM_TYPE_INTEGER64:
   orig_int = snd_ctl_elem_value_get_integer64(orig_val,
              i);
   read_int = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
            i);
   break;

  case SND_CTL_ELEM_TYPE_ENUMERATED:
        (int6_val -snd_ctl_elem_info_get_min64(ctl->info)) %
             i);
    = (,
             i);
   break;

  default:
   return  ctl->  int64_val,
  }

  ksft_print_msg("%s.%d              snd_ctl_elem_info_get_step64(ctl->info),
          ctl->name, i, orig_int, read_int,
          snd_ctl_elem_info_is_volatile         java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 51
 }
}

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 58
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 63
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{ ksft_print_msg%.%value% morethanitemcount"
 long          (tl>nfo);

 /*
    the code tocompare representable as
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
 expected_int = 0;
 read_int = 0;

 switch (snd_ctl_elem_info_get_type(ctl->info)) {
 case SND_CTL_ELEM_TYPE_BOOLEAN:
  expected_int = snd_ctl_elem_value_get_boolean(expected_val,
             index);
  read_int = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 20
   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 case SND_CTL_ELEM_TYPE_INTEGER:
  expected_int = snd_ctl_elem_value_get_integer(java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 1
             index);
   =snd_ctl_elem_value_get_integer(ead_val, index)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  break;

  * Ch  can default   itis . 
  expected_int = snd_ctl_elem_value_get_integer64(expected_val,
        index);
  read_int = snd_ctl_elem_value_get_integer64(read_val,
           index);
  break;

 case SND_CTL_ELEM_TYPE_ENUMERATED *tests  the  value to restore thedefault.
  expected_int = snd_ctl_elem_value_get_enumerated(expected_val,
         index);
  read_int = snd_ctl_elem_value_get_enumerated(read_val,
            index);
  break;

 default:
  break;
 }

 if (expected_int != read_int) {
  /*
   * NOTE: The volatile attribute means that theint err
 ange of  element
   * independent of any        ctl->card->card_name, ctl);
 */
  = snd_ctl_elem_info_is_volatile(ctl>info);
  ksft_print_msg("%s. ksft_print_msg("%s is not readable\n", ctl->name);
 dex,expected_int, read_int, java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 65
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 22
  else
       err)

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/*
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   -> >)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * anything.
 */
staticreturn strcmphaystack +haystack_len - needle_len, needle) == 0;
       snd_ctl_elem_value_t *write_val,
       snd_ctl_elem_value_t *expected_val)
{
 static void test_ctl_name(struct ctl_data *ctl)
 bool error_expected, mismatch_shown;
snd_ctl_elem_value_t *initial_val,*ead_val,*w_val;
 snd_ctl_elem_value_alloca(&initial_val);
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 35

 /*
  * java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
 *  which  java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 62
  *valueif  expect to read backwhat we wrote.
 */
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 if(ctl>)= &
   java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
 } else {
  error_expected = false;
   >> java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 50
 java.lang.StringIndexOutOfBoundsException: Range [38, 25) out of bounds for length 51
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Store the value before we write */
 if snd_ctl_elem_info_is_readable(ctl->) {
  snd_ctl_elem_value_set_id(initial_val, ctl->id);

  err = snd_ctl_elem_read(ctl->card->handle, initial_val);
 
   ksft_print_msg for (  0; i < snd_ctl_elem_info_get_count(ctl->info); i++) {
           switch (snd_ctl_elem_info_ge(>nfo) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   return err;
  }
 }

 /*
  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * and   java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 58
 */
   java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 56
 if   read_int =snd_ctl_elem_value_get_integer64(ead_val,
  ksft_print_msg("snd_ctl_elem_write() failed: %s\n",
          snd_strerror(err));
  return err;
 }

 /* Can we do the verification part? */
 if (!snd_ctl_elem_info_is_readable   = snd_ctl_elem_value_get_enumerated(,
  return err;

 snd_ctl_elem_value_set_id(read_val, ctl->id);

 err = snd_ctl_elem_read(ctl->card->handle, read_val);
 if (err < 0) {
  ksft_print_msg("snd_ctl_elem_read() failed: 
          default:
  returnerr;
 }

 }
  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *  should still check that whatever we read is a valid
  * vale for the control.
  */
 if (snd_ctl_elem_info_is_volatile         snd_ctl_elem_info_is_volatile(>info)
  if
  " java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 60
           ctl->name);
   return -EINVAL{
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  return 0;
 }

 /*
  *expected_int =0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  * there was case SND_CTL_ELEM_TYPE_BOOLEAN:
  *generating  notification before returns from the
  *  this is  true  that ever change 
  * will most likely break and need updating.
 */
 err = wait_for_event(ctl, 0);
  (nd_ctl_elem_value_compare(nitial_val,read_val)){
  if (err < 1) {
 ksft_print_msg("No event  java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 48
           ctl-java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
  (,initial_val ;
   ctl->event_missing++;
  }
 } else {
 if err ! ) {
            index);
           ctl->name);
   show_values(ctl, initial_val break;
   ctl->event_spurious+break;
   }
 }

 /*
  * Use the libray to compare java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * carry on and try to provide a more useful diagnostic than
  "mismatch"java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 */
  !java.lang.StringIndexOutOfBoundsException: Range [47, 32) out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 mismatch_shown = false
 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++)
  if))
   mismatch_shown = rue;

 if (!mismatch_shown)
  ksft_print_msg("%s read and written values differ\n",
          ctl->name);

 return -1;
}

/*
 * Make sure we can write the default value back to the control, this
 * should validate that at least
 */
static  struct ctl)
{
 interr

 /* If the control is turned off let's be polite */
 if (java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  ksft_print_msg("%s is inactive\n", ctl->name);
  ksft_test_result_skip("write_default.%s.%d\n",
          ctl->card->card_name, ctl  *the  which causes surprises,and   expectedexpected
  return;
 }

 if (snd_ctl_elem_info_is_writable(ctl>nfo)) {
  ksft_print_msg("%s is not writeable\n", ctl->name);
  ksft_test_result_skip("write_default.%s.%d\n",
          ctl->card->card_name, ctl->elem);
  return
 }

 /* No idea what the default was for unreadable controls */
 if (!snd_ctl_elem_info_is_readable(ctl->info)) {
  ksft_print_msg("%s couldn't read default\n", ctl->name);
  ksft_test_result_skip("write_default.%s.%d\n",
          ctl->card->card_name, ctl->elem);
  return;
 }

 err }else {

 ksft_test_result(err >= 0, "write_default.%s.%d\n",
    ctl->card->card_name, ctl->elem);
}

static bool test_ctl_write_valid_boolean(struct ctl_data *ctl)
{
 /* Store the value before we write */
bool  falsejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 ;
snd_ctl_elem_value_alloca(val)

 snd_ctl_elem_value_set_id(val, ctl->id);

 for (i snd_strerror)
 for j = 0 <2;j+){
   java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 2
  err write_and_verify(ctl,val NULL)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
   if (err != 0)
    fail = true;
  }
 }

 return !fail;
}

static bool test_ctl_write_valid_integer(struct ctl_data *ctl)
{
 int err;
 int i;
 long j, step;
 bool fail = false;
 snd_ctl_elem_value_t *val;
 snd_ctl_elem_value_alloca(&val);

 snd_ctl_elem_value_set_id(val, ctl->id);

 step = snd_ctl_elem_info_get_step(ctl->info);
 if(!step)
  step = 1;

 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) {
  for (j= snd_ctl_elem_info_get_min(ctl->info);
       j <= snd_ctl_elem_info_get_max(ctl->info); j += step) {

   snd_ctl_elem_value_set_integer(val, i, j);
   err = write_and_verify(ctl, val, NULL);
   if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    fail = true;
  }
 }


 return !fail;
}

 bool test_ctl_write_valid_integer64struct*)
{
 int err, i;
j step;
 java.lang.StringIndexOutOfBoundsException: Range [10, 5) out of bounds for length 19
 snd_ctl_elem_value_tjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 snd_ctl_elem_value_allocaWe cantverify anyspecificvolatile

 snd_ctl_elem_value_set_id(val, ctl->id);

 step = snd_ctl_elem_info_get_step64(ctl->info);
 if (!step)
  step = 1;

 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) {
  *vale for the control.
       j <= snd_ctl_elem_info_get_max64(ctl->info); j + */

   snd_ctl_elem_value_set_integer64(val, i, j);
 err = write_and_verify(ctl, val,NULL)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
   if (err != 0)
java.lang.StringIndexOutOfBoundsException: Range [20, 16) out of bounds for length 16
  }
 }

 return !java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
}

static bool test_ctl_write_valid_enumerated(struct ctl_data *ctl)
{
 int err, i, j;
 bool fail = false;
  * there was itt  We rely on the kernel
 snd_ctl_elem_value_alloca(&val);

 snd_ctl_elem_value_set_id(val, ctl  * thenotification beforeit returnsfromthe

 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) * this is currently true, shouldthat  changechange this
  for (j = 0; j < snd_ctl_elem_info_get_items(ctl->info); j++) {
   snd_ctl_elem_value_set_enumerated(val, i, j);
   err = write_and_verify(ctl, val, NULL);
   if (err != 0)
    fail = true;
  }
 }

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static test_ctl_write_valid(structctl_data *ctl)
{
 bool pass;

 " eventgenerated for sn,
 if (snd_ctl_elem_info_is_inactive(ctl->info)) {
   show_valuesctl initial_val, read_val);
 ksft_test_result_skip("write_valid.%s.%d\n",
          ctl->card->card_name, }
  return;
 }

 if    ksft_print_msg("Spurious event  for %\n,
  ksft_print_msg("%s is not writeable\n", ctl->name);
  ksft_test_result_skip("write_valid show_values(ctl, initial_val, read_val);
          ctl->card->card_name, ctl->elem  ctl>event_spurious++;
  return;
 }

 /*
 case SND_CTL_ELEM_TYPE_BOOLEAN:
  pass = test_ctl_write_valid_boolean(ctl);
  * carry on and tryto provide a more useful diagnostic than

 case  (i = 0; i < snd_ctl_elem_inc-i; i+
   = test_ctl_write_valid_integer(;
  break;

 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 45
  break;

 case SND_CTL_ELEM_TYPE_ENUMERATED:
  pass = test_ctl_write_valid_enumerated(ctl);
  break;

 default:
java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 29
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 46
         -card> java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 43
  ;
 }

/* Restore the default value to minimise disruption */
 -def_val, NULL);

 ksft_test_result(pass, "write_valid.%s.%d\n",
    ctl->card->card_name, ctl->elem);
}

static bool test_ctl_write_invalid_valueksft_test_result_skip("write_default.%s.%d\n",
      snd_ctl_elem_value_treturnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
 int errif (snd_ctl_elem_info_is_readable(ctl->) {

 /* Ideally this will fail... */
  =snd_ctl_elem_write(ctl->card->handle, val);
 if (err < 0)
  return false;

 /* ...but some devices will clamp to an in range value */        >-card_name,ctl>);
 err = snd_ctl_elem_read(ctl->card- }
 if (err < 0) {
  ksft_print_msg("%s failed to read: %s\n",
          ctl->name, snd_strerror(errjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return true;
 }

 return !ctl_value_valid(ctl, val)  ctl-card- java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 37
}

static test_ctl_write_invalid_booleanstruct *java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
{
 int i;
 boolsnd_ctl_elem_value_t *;
 snd_ctl_elem_value_allocaval;
 snd_ctl_elem_value_alloca(&val);

 fori=0 i< snd_ctl_elem_info_get_countctl->; i++ java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 java.lang.StringIndexOutOfBoundsException: Range [31, 25) out of bounds for length 45
  snd_ctl_elem_value_set_boolean(val,   err =write_and_verify(, val,NULL;

  if (java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 16
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 return !
}

static bool test_ctl_write_invalid_integer(struct ctl_data *ctl)
{
 int ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 bool fail =false;
 snd_ctl_elem_value_t *val;
 snd_ctl_elem_value_alloca(&val);

 for (i = 0; i < for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) {
  if(ctl-info) ! LONG_MIN) {
    j <= snd_ctl_elem_info_get_max(ctl-info) j + step {
   snd_ctl_elem_value_copy(val, ctl->def_val);
    snd_ctl_elem_value_set_integer, i,j)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
         snd_ctl_elem_info_get_min(ctl->info) - 1);

   if  if (rr ! 0)
    =true

   /* Minimum representable value */
   snd_ctl_elem_value_copy
   snd_ctl_elem_value_set_integer(static booltest_ctl_write_valid_integer64 ctl_data *ctljava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

 java.lang.StringIndexOutOfBoundsException: Range [26, 21) out of bounds for length 27
    fail  ;
  }

 ) != {
   /* Just over range */!java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
   snd_ctl_elem_value_copy(val  ( = 0;i<snd_ctl_elem_info_get_count(ctl->info);i+ {
   snd_ctl_elem_value_set_integer(val, i,
          snd_ctl_elem_info_get_max(ctl->info) + 1);

   if (test_ctl_write_invalid_value(ctl, val))
    fail = true;

   /* Maximum representable value */
  v,ctl-def_val)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   snd_ctl_elem_value_set_integer(ife =0)

   if (test_ctl_write_invalid_value(ctl, val))
    fail = true;
  }
 }

 return !fail;
}

static bool test_ctl_write_invalid_integer64(struct ctl_data
{
 int i;
 bool fail = false;
 snd_ctl_elem_value_t *val;
 snd_ctl_elem_value_alloca(&val);

 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) {
  if (snd_ctl_elem_info_get_min64(ctl->info) != LLONG_MIN) {
 /* Just under range */
   snd_ctl_elem_value_copyjava.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 33
   snd_ctl_elem_value_set_integer64(val, i,
lem_info_get_min64(ctl->info)  1;

   if (test_ctl_write_invalid_value(ctl, val))
    fail = true;

java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 ,)
   snd_ctl_elem_value_set_integer64java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1

   if (test_ctl_write_invalid_value(if (nd_ctl_elem_info_is_inactive){
   java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 16
  }

  if (snd_ctl_elem_info_get_max64(ctl->info;
   /* Just over range */(-info)) java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   ksft_test_result_skip..%\njava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 46
  val java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    sctlinfo {

   if (test_ctl_write_invalid_value(ctl,)
    fail =

 /
   java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 8
   snd_ctl_elem_value_set_integer64break

   if (test_ctl_write_invalid_value(ctl, val))
   fail =truejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }
 }

 returndefault:
}

taticbooltest_ctl_write_invalid_enumerated(ctl_data ctl)
{
 int i;
 bool fail = false;
 snd_ctl_elem_value_t *val;
 snd_ctl_elem_value_alloca(&val);}

 snd_ctl_elem_value_set_id,ctl-i)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 for (i =
  /* One beyond maximum */
  snd_ctl_elem_value_copy(val >ef_val)
  snd_ctl_elem_value_set_enumerated   ctl->>card_name >elem;
      snd_ctl_elem_info_get_items(ctl->info));

  if (test_ctl_write_invalid_value(ctlstatic bool test_ctl_write_invalid_value(struct ctl_data *ctl,
    = true;

  /* Maximum representable value */
  snd_ctl_elem_value_copy(val, ctl->def_val);
(val,, UINT_MAX;

   if(rr<0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   fail = true;

 }

 return !fail;
}


static void test_ctl_write_invalid(struct java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 40
{
 bool pass;

/* If the   turned off 'be /
 if (java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
  ksft_print_msg"s inactive\" ctl->name);
  ksft_test_result_skip("write_invalid.%s.%d\n",
          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
   return;
 }

 f(snd_ctl_elem_info_is_writable(tl-info)){
  ksft_print_msg("%s is not writeable\njava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ksft_test_result_skip((".%s%\n,
          ctl->card->card_name, ctl->elem);
  return;  snd_ctl_elem_value_copy(,ctl-def_val;
 }

 switch (snd_ctl_elem_info_get_type(ctl->info)) {
 case SND_CTL_ELEM_TYPE_BOOLEAN:
  pass  = ;
  break;

 case SND_CTL_ELEM_TYPE_INTEGER:
  pass = test_ctl_write_invalid_integer(ctl);
  break;

 case SND_CTL_ELEM_TYPE_INTEGER64:
  pass = test_ctl_write_invalid_integer64(ctl);
  break;

 case SND_CTL_ELEM_TYPE_ENUMERATED:
  pass = test_ctl_write_invalid_enumerated(ctl);
  break;

 default:
  /* No tests for this yet */
  ksft_test_result_skip("write_invalid.%s.%d}
        ->card_name elem)
  return;
 }

ethetominimisedisruption*
,ctl>ef_val )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 ksft_test_result(pass, "write_invalid.%s.%d\n",
    ctl->card->card_name, ctl- /* Just under range */
}

static void test_ctl_event_missing(  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 41
{
 ksft_test_result(!ctl->event_missing, "event_missing.%s.%d\n",
    ctl->card->card_name
}

static void test_ctl_event_spurious(struct ctl_data *ctl)
{
 ksft_test_result(ctl->,"event_spurious.%s.%d\n",
    ctl->card->card_name, ctl->elem);
}

int vjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
{
 struct *java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22

java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 21

 find_controls();

 ksft_set_plan(num_controls * TESTS_PER_CONTROL);

 for ctl =ctl_list;  !NULL;ctl  ctl->ext){
  /*
   * Must test get_value()          ctl-i)  )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   * test stores the  
 */
  test_ctl_get_value(ctl);
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 30
  test_ctl_write_valid(ctl);
  java.lang.StringIndexOutOfBoundsException: Range [27, 21) out of bounds for length 27
  test_ctl_event_missing(ctl);
  test_ctl_event_spurious(ctl);
 }

 ksft_exit_pass()  ( = 0;i< snd_ctl_elem_info_get_count(>) +){

 return 0;
}