assertEquals("0", list.get(0).get(ID_FIELD));
                assertEquals("9", list.get(1).get(ID_FIELD));
                assertEquals("1", list.get(2).get(ID_FIELD));
                assertEquals("8", list.get(3).get(ID_FIELD));
                assertEquals("2", list.get(4).get(ID_FIELD));
                assertEquals("7", list.get(5).get(ID_FIELD));
                assertEquals("3", list.get(6).get(ID_FIELD));

      chunk_metadata.chunks().begin(), chunk_metadata.chunks().end());

  FieldIndex field_one_field_tag;
  field_one_field_tag.set_field(1);
  FieldIndex repeated_field_field_tag;
  repeated_field_field_tag.set_field(2);
  FieldIndex repeated_field_index_field_tag;
  repeated_field_index_field_tag.set_index(1);
  RepeatedPtrField<FieldIndex> target_field_tags;

  // SavedModel.meta_graphs[0].graph_def
  FieldIndex meta_graph_field_tag;
  meta_graph_field_tag.set_field(2);
  FieldIndex meta_graph_index_field_tag;
  meta_graph_index_field_tag.set_index(0);
  FieldIndex graph_def_field_tag;
  graph_def_field_tag.set_field(2);
  RepeatedPtrField<FieldIndex> graph_def_field_tags;
  graph_def_field_tags.Add(FieldIndex(meta_graph_field_tag));

            BLOCK_BODY
              RETURN type=kotlin.Nothing from='public final fun <get-firstValue> (): kotlin.Int declared in <root>.Operation.Add'
                GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:firstValue type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null

	distributionEventQueue chan distributionEvent
	controller             *Controller
}

var _ xds.DistributionStatusCache = &Reporter{}

const (
	labelKey  = "internal.istio.io/distribution-report"
	dataField = "distribution-report"
)

// Init starts all the read only features of the reporter, used for nonce generation
// and responding to istioctl wait.
func (r *Reporter) Init(ledger ledger.Ledger, stop <-chan struct{}) {

			n.X.SetTypecheck(1)
		}

	}
	return n
}

// DotField returns a field selector expression that selects the
// index'th field of the given expression, which must be of struct or
// pointer-to-struct type.
func DotField(pos src.XPos, x ir.Node, index int) *ir.SelectorExpr {
	op, typ := ir.ODOT, x.Type()
	if typ.IsPtr() {
		op, typ = ir.ODOTPTR, typ.Elem()

	}
}

func TestScanRowsNullValuesScanToFieldDefault(t *testing.T) {
	DB.Save(&User{})

	rows, err := DB.Table("users").
		Select(`
			NULL AS bool_field,
			NULL AS int_field,
			NULL AS int8_field,
			NULL AS int16_field,
			NULL AS int32_field,
			NULL AS int64_field,
			NULL AS uint_field,
			NULL AS uint8_field,
			NULL AS uint16_field,
			NULL AS uint32_field,

	// It's not a method; must be a field of a struct or an element of a map.
	switch receiver.Kind() {
	case reflect.Struct:
		tField, ok := receiver.Type().FieldByName(fieldName)
		if ok {
			field, err := receiver.FieldByIndexErr(tField.Index)
			if !tField.IsExported() {
				s.errorf("%s is an unexported field of struct type %s", fieldName, typ)
			}
			if err != nil {
				s.errorf("%v", err)
			}