# generated from the original tests.
# Henceforth it may be nicer to group tests into separate files.
-- in.cue --
import "list"

t1: list.Avg([1, 2, 3, 4])
t2: list.Avg([])
t3: list.Avg("foo")
t4: list.Drop([1, 2, 3, 4], 0)
t5: list.Drop([1, 2, 3, 4], 2)
t6: list.Drop([1, 2, 3, 4], 10)
t7: list.Drop([1, 2, 3, 4], -1)
t8: list.FlattenN([1, [[2, 3], []], [4]], -1)
t9: list.FlattenN([1, [[2, 3], []], [4]], 0)
t10: list.FlattenN([1, [[2, 3], []], [4]], 1)
t11: list.FlattenN([1, [[2, 3], []], [4]], 2)
t12: list.FlattenN([[1, 2] | *[]], -1)
t13: list.FlattenN("foo", 1)
t14: list.FlattenN([], "foo")
t15: list.Max([1, 2, 3, 4])
t16: list.Max([])
t17: list.Max("foo")
t18: list.Min([1, 2, 3, 4])
t19: list.Min([])
t20: list.Min("foo")
t21: list.Product([1, 2, 3, 4])
t22: list.Product([])
t23: list.Product("foo")
t24: list.Range(0, 5, 0)
t25: list.Range(5, 0, 1)
t26: list.Range(0, 5, -1)
t27: list.Range(0, 5, 1)
t28: list.Range(0, 1, 1)
t29: list.Range(0, 5, 2)
t30: list.Range(5, 0, -1)
t31: list.Range(0, 5, 0.5)
t32: list.Slice([1, 2, 3, 4], 1, 3)
t33: list.Slice([1, 2, 3, 4], -1, 3)
t34: list.Slice([1, 2, 3, 4], 3, 1)
t35: list.Slice([1, 2, 3, 4], 5, 5)
t36: list.Slice([1, 2, 3, 4], 1, 5)
t37: list.Sort([], list.Ascending)
t38: list.Sort([2, 3, 1, 4], {x:_, y:_, less: x<y})
t39: list.SortStable([{a:2,v:1}, {a:1,v:2}, {a:1,v:3}], {
			x:_,
			y:_,
			less: (x.a < y.a)
		})
t40: list.Sort([{a:1}, {b:2}], list.Ascending)
t41: list.SortStrings(["b", "a"])
t42: list.SortStrings([1, 2])
t43: list.Sum([1, 2, 3, 4])
t44: list.Sum([])
t45: list.Sum("foo")
t46: list.Take([1, 2, 3, 4], 0)
t47: list.Take([1, 2, 3, 4], 2)
t48: list.Take([1, 2, 3, 4], 10)
t49: list.Take([1, 2, 3, 4], -1)
t50: list.MinItems([1, 2, 3, 4], 2)
t51: list.MinItems([1, 2, 3, 4], 5)
t52: list.MaxItems([1, 2, 3, 4], 5)
t53: list.MaxItems([1, 2, 3, 4], 2)
t54: list.Sort([{a:1}, {b:2}], list.Ascending)
-- out/list --
Errors:
error in call to list.Avg: empty list
error in call to list.Drop: negative index
error in call to list.FlattenN: cannot use value "foo" (type string) as list
error in call to list.Max: empty list
error in call to list.Min: empty list
error in call to list.Range: end must be greater than start when step is positive
error in call to list.Range: end must be less than start when step is negative
error in call to list.Range: step must be non zero
error in call to list.Slice: invalid index: 3 > 1
error in call to list.Slice: negative index
error in call to list.Slice: slice bounds out of range
error in call to list.Take: negative index
0: error in call to list.SortStrings: element 0 of list argument 0: cannot use value 1 (type int) as string
x: error in call to list.Sort: conflicting values string and {b:2} (mismatched types string and struct)
y: error in call to list.Sort: conflicting values string and {a:1} (mismatched types string and struct)
t3: cannot use "foo" (type string) as list in argument 1 to list.Avg:
    ./in.cue:5:14
t14: cannot use "foo" (type string) as int in argument 2 to list.FlattenN:
    ./in.cue:16:24
t17: cannot use "foo" (type string) as list in argument 1 to list.Max:
    ./in.cue:19:15
t20: cannot use "foo" (type string) as list in argument 1 to list.Min:
    ./in.cue:22:15
t23: cannot use "foo" (type string) as list in argument 1 to list.Product:
    ./in.cue:25:19
t45: cannot use "foo" (type string) as list in argument 1 to list.Sum:
    ./in.cue:51:15

Result:
(_|_){
  // [eval]
  t1: (float){ 2.5 }
  t2: (_|_){
    // [eval] error in call to list.Avg: empty list
  }
  t3: (_|_){
    // [eval] t3: cannot use "foo" (type string) as list in argument 1 to list.Avg:
    //     ./in.cue:5:14
  }
  t4: (#list){
    0: (int){ 1 }
    1: (int){ 2 }
    2: (int){ 3 }
    3: (int){ 4 }
  }
  t5: (#list){
    0: (int){ 3 }
    1: (int){ 4 }
  }
  t6: (#list){
  }
  t7: (_|_){
    // [eval] error in call to list.Drop: negative index
  }
  t8: (#list){
    0: (int){ 1 }
    1: (int){ 2 }
    2: (int){ 3 }
    3: (int){ 4 }
  }
  t9: (#list){
    0: (int){ 1 }
    1: (#list){
      0: (#list){
        0: (int){ 2 }
        1: (int){ 3 }
      }
      1: (#list){
      }
    }
    2: (#list){
      0: (int){ 4 }
    }
  }
  t10: (#list){
    0: (int){ 1 }
    1: (#list){
      0: (int){ 2 }
      1: (int){ 3 }
    }
    2: (#list){
    }
    3: (int){ 4 }
  }
  t11: (#list){
    0: (int){ 1 }
    1: (int){ 2 }
    2: (int){ 3 }
    3: (int){ 4 }
  }
  t12: (#list){
  }
  t13: (_|_){
    // [eval] error in call to list.FlattenN: cannot use value "foo" (type string) as list
  }
  t14: (_|_){
    // [eval] t14: cannot use "foo" (type string) as int in argument 2 to list.FlattenN:
    //     ./in.cue:16:24
  }
  t15: (float){ 4 }
  t16: (_|_){
    // [eval] error in call to list.Max: empty list
  }
  t17: (_|_){
    // [eval] t17: cannot use "foo" (type string) as list in argument 1 to list.Max:
    //     ./in.cue:19:15
  }
  t18: (float){ 1 }
  t19: (_|_){
    // [eval] error in call to list.Min: empty list
  }
  t20: (_|_){
    // [eval] t20: cannot use "foo" (type string) as list in argument 1 to list.Min:
    //     ./in.cue:22:15
  }
  t21: (float){ 24 }
  t22: (float){ 1 }
  t23: (_|_){
    // [eval] t23: cannot use "foo" (type string) as list in argument 1 to list.Product:
    //     ./in.cue:25:19
  }
  t24: (_|_){
    // [eval] error in call to list.Range: step must be non zero
  }
  t25: (_|_){
    // [eval] error in call to list.Range: end must be greater than start when step is positive
  }
  t26: (_|_){
    // [eval] error in call to list.Range: end must be less than start when step is negative
  }
  t27: (#list){
    0: (float){ 0 }
    1: (float){ 1 }
    2: (float){ 2 }
    3: (float){ 3 }
    4: (float){ 4 }
  }
  t28: (#list){
    0: (float){ 0 }
  }
  t29: (#list){
    0: (float){ 0 }
    1: (float){ 2 }
    2: (float){ 4 }
  }
  t30: (#list){
    0: (float){ 5 }
    1: (float){ 4 }
    2: (float){ 3 }
    3: (float){ 2 }
    4: (float){ 1 }
  }
  t31: (#list){
    0: (float){ 0 }
    1: (float){ 0.5 }
    2: (float){ 1.0 }
    3: (float){ 1.5 }
    4: (float){ 2.0 }
    5: (float){ 2.5 }
    6: (float){ 3.0 }
    7: (float){ 3.5 }
    8: (float){ 4.0 }
    9: (float){ 4.5 }
  }
  t32: (#list){
    0: (int){ 2 }
    1: (int){ 3 }
  }
  t33: (_|_){
    // [eval] error in call to list.Slice: negative index
  }
  t34: (_|_){
    // [eval] error in call to list.Slice: invalid index: 3 > 1
  }
  t35: (_|_){
    // [eval] error in call to list.Slice: slice bounds out of range
  }
  t36: (_|_){
    // [eval] error in call to list.Slice: slice bounds out of range
  }
  t37: (#list){
  }
  t38: (#list){
    0: (int){ 1 }
    1: (int){ 2 }
    2: (int){ 3 }
    3: (int){ 4 }
  }
  t39: (#list){
    0: (struct){
      a: (int){ 1 }
      v: (int){ 2 }
    }
    1: (struct){
      a: (int){ 1 }
      v: (int){ 3 }
    }
    2: (struct){
      a: (int){ 2 }
      v: (int){ 1 }
    }
  }
  t40: (_|_){
    // [eval] x: error in call to list.Sort: conflicting values string and {b:2} (mismatched types string and struct)
    // y: error in call to list.Sort: conflicting values string and {a:1} (mismatched types string and struct)
  }
  t41: (#list){
    0: (string){ "a" }
    1: (string){ "b" }
  }
  t42: (_|_){
    // [eval] 0: error in call to list.SortStrings: element 0 of list argument 0: cannot use value 1 (type int) as string
  }
  t43: (float){ 10 }
  t44: (float){ 0 }
  t45: (_|_){
    // [eval] t45: cannot use "foo" (type string) as list in argument 1 to list.Sum:
    //     ./in.cue:51:15
  }
  t46: (#list){
  }
  t47: (#list){
    0: (int){ 1 }
    1: (int){ 2 }
  }
  t48: (#list){
    0: (int){ 1 }
    1: (int){ 2 }
    2: (int){ 3 }
    3: (int){ 4 }
  }
  t49: (_|_){
    // [eval] error in call to list.Take: negative index
  }
  t50: (bool){ true }
  t51: (bool){ false }
  t52: (bool){ true }
  t53: (bool){ false }
  t54: (_|_){
    // [eval] x: error in call to list.Sort: conflicting values string and {b:2} (mismatched types string and struct)
    // y: error in call to list.Sort: conflicting values string and {a:1} (mismatched types string and struct)
  }
}