mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-21 16:54:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #17174 from Snektron/spirv-stuffies

Browse Source 
spirv gaming
This commit is contained in:
Andrew Kelley 2023-09-23 12:37:48 -07:00 committed by GitHub
commit b00287175c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
71 changed files with 1307 additions and 1164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1960
src/codegen/spirv.zig
View File

File diff suppressed because it is too large Load Diff

12
src/codegen/spirv/Cache.zig
View File

@ -462,11 +462,11 @@ fn emit(
switch (key) {
.void_type => {
try section.emit(spv.gpa, .OpTypeVoid, .{ .id_result = result_id });
try spv.debugName(result_id, "void", .{});
try spv.debugName(result_id, "void");
},
.bool_type => {
try section.emit(spv.gpa, .OpTypeBool, .{ .id_result = result_id });
try spv.debugName(result_id, "bool", .{});
try spv.debugName(result_id, "bool");
},
.int_type => |int| {
try section.emit(spv.gpa, .OpTypeInt, .{
@ -481,14 +481,14 @@ fn emit(
.unsigned => "u",
.signed => "i",
};
try spv.debugName(result_id, "{s}{}", .{ ui, int.bits });
try spv.debugNameFmt(result_id, "{s}{}", .{ ui, int.bits });
},
.float_type => |float| {
try section.emit(spv.gpa, .OpTypeFloat, .{
.id_result = result_id,
.width = float.bits,
});
try spv.debugName(result_id, "f{}", .{float.bits});
try spv.debugNameFmt(result_id, "f{}", .{float.bits});
},
.vector_type => |vector| {
try section.emit(spv.gpa, .OpTypeVector, .{
@ -530,11 +530,11 @@ fn emit(
section.writeOperand(IdResult, self.resultId(member_type));
}
if (self.getString(struct_type.name)) |name| {
try spv.debugName(result_id, "{s}", .{name});
try spv.debugName(result_id, name);
}
for (struct_type.memberNames(), 0..) |member_name, i| {
if (self.getString(member_name)) |name| {
try spv.memberDebugName(result_id, @as(u32, @intCast(i)), "{s}", .{name});
try spv.memberDebugName(result_id, @as(u32, @intCast(i)), name);
}
}
// TODO: Decorations?

121
src/codegen/spirv/Module.zig
View File

@ -94,6 +94,8 @@ pub const Global = struct {
begin_inst: u32,
/// The past-end offset into `self.flobals.section`.
end_inst: u32,
/// The result-id of the function that initializes this value.
initializer_id: IdRef,
};
/// This models a kernel entry point.
@ -284,6 +286,10 @@ fn addEntryPointDeps(
const decl = self.declPtr(decl_index);
const deps = self.decl_deps.items[decl.begin_dep..decl.end_dep];
if (seen.isSet(@intFromEnum(decl_index))) {
return;
}
seen.set(@intFromEnum(decl_index));
if (self.globalPtr(decl_index)) |global| {
@ -291,9 +297,7 @@ fn addEntryPointDeps(
}
for (deps) |dep| {
if (!seen.isSet(@intFromEnum(dep))) {
try self.addEntryPointDeps(dep, seen, interface);
}
try self.addEntryPointDeps(dep, seen, interface);
}
}
@ -325,20 +329,76 @@ fn entryPoints(self: *Module) !Section {
return entry_points;
}
/// Generate a function that calls all initialization functions,
/// in unspecified order (an order should not be required here).
/// It generated as follows:
/// %init = OpFunction %void None
/// foreach %initializer:
/// OpFunctionCall %initializer
/// OpReturn
/// OpFunctionEnd
fn initializer(self: *Module, entry_points: *Section) !Section {
var section = Section{};
errdefer section.deinit(self.gpa);
// const void_ty_ref = try self.resolveType(Type.void, .direct);
const void_ty_ref = try self.resolve(.void_type);
const void_ty_id = self.resultId(void_ty_ref);
const init_proto_ty_ref = try self.resolve(.{ .function_type = .{
.return_type = void_ty_ref,
.parameters = &.{},
} });
const init_id = self.allocId();
try section.emit(self.gpa, .OpFunction, .{
.id_result_type = void_ty_id,
.id_result = init_id,
.function_control = .{},
.function_type = self.resultId(init_proto_ty_ref),
});
try section.emit(self.gpa, .OpLabel, .{
.id_result = self.allocId(),
});
var seen = try std.DynamicBitSetUnmanaged.initEmpty(self.gpa, self.decls.items.len);
defer seen.deinit(self.gpa);
var interface = std.ArrayList(IdRef).init(self.gpa);
defer interface.deinit();
for (self.globals.globals.keys(), self.globals.globals.values()) |decl_index, global| {
try self.addEntryPointDeps(decl_index, &seen, &interface);
try section.emit(self.gpa, .OpFunctionCall, .{
.id_result_type = void_ty_id,
.id_result = self.allocId(),
.function = global.initializer_id,
});
}
try section.emit(self.gpa, .OpReturn, {});
try section.emit(self.gpa, .OpFunctionEnd, {});
try entry_points.emit(self.gpa, .OpEntryPoint, .{
// TODO: Rusticl does not support this because its poorly defined.
// Do we need to generate a workaround here?
.execution_model = .Kernel,
.entry_point = init_id,
.name = "zig global initializer",
.interface = interface.items,
});
try self.sections.execution_modes.emit(self.gpa, .OpExecutionMode, .{
.entry_point = init_id,
.mode = .Initializer,
});
return section;
}
/// Emit this module as a spir-v binary.
pub fn flush(self: *Module, file: std.fs.File) !void {
// See SPIR-V Spec section 2.3, "Physical Layout of a SPIR-V Module and Instruction"
const header = [_]Word{
spec.magic_number,
// TODO: From cpu features
// Emit SPIR-V 1.4 for now. This is the highest version that Intel's CPU OpenCL supports.
(1 << 16) | (4 << 8),
0, // TODO: Register Zig compiler magic number.
self.idBound(),
0, // Schema (currently reserved for future use)
};
// TODO: Perform topological sort on the globals.
var globals = try self.orderGlobals();
defer globals.deinit(self.gpa);
@ -349,6 +409,19 @@ pub fn flush(self: *Module, file: std.fs.File) !void {
var types_constants = try self.cache.materialize(self);
defer types_constants.deinit(self.gpa);
var init_func = try self.initializer(&entry_points);
defer init_func.deinit(self.gpa);
const header = [_]Word{
spec.magic_number,
// TODO: From cpu features
// Emit SPIR-V 1.4 for now. This is the highest version that Intel's CPU OpenCL supports.
(1 << 16) | (4 << 8),
0, // TODO: Register Zig compiler magic number.
self.idBound(),
0, // Schema (currently reserved for future use)
};
// Note: needs to be kept in order according to section 2.3!
const buffers = &[_][]const Word{
&header,
@ -363,6 +436,7 @@ pub fn flush(self: *Module, file: std.fs.File) !void {
self.sections.types_globals_constants.toWords(),
globals.toWords(),
self.sections.functions.toWords(),
init_func.toWords(),
};
var iovc_buffers: [buffers.len]std.os.iovec_const = undefined;
@ -524,6 +598,7 @@ pub fn allocDecl(self: *Module, kind: DeclKind) !Decl.Index {
.result_id = undefined,
.begin_inst = undefined,
.end_inst = undefined,
.initializer_id = undefined,
}),
}
@ -553,10 +628,14 @@ pub fn beginGlobal(self: *Module) u32 {
return @as(u32, @intCast(self.globals.section.instructions.items.len));
}
pub fn endGlobal(self: *Module, global_index: Decl.Index, begin_inst: u32) void {
pub fn endGlobal(self: *Module, global_index: Decl.Index, begin_inst: u32, result_id: IdRef, initializer_id: IdRef) void {
const global = self.globalPtr(global_index).?;
global.begin_inst = begin_inst;
global.end_inst = @as(u32, @intCast(self.globals.section.instructions.items.len));
global.* = .{
.result_id = result_id,
.begin_inst = begin_inst,
.end_inst = @intCast(self.globals.section.instructions.items.len),
.initializer_id = initializer_id,
};
}
pub fn declareEntryPoint(self: *Module, decl_index: Decl.Index, name: []const u8) !void {
@ -566,18 +645,20 @@ pub fn declareEntryPoint(self: *Module, decl_index: Decl.Index, name: []const u8
});
}
pub fn debugName(self: *Module, target: IdResult, comptime fmt: []const u8, args: anytype) !void {
const name = try std.fmt.allocPrint(self.gpa, fmt, args);
defer self.gpa.free(name);
pub fn debugName(self: *Module, target: IdResult, name: []const u8) !void {
try self.sections.debug_names.emit(self.gpa, .OpName, .{
.target = target,
.name = name,
});
}
pub fn memberDebugName(self: *Module, target: IdResult, member: u32, comptime fmt: []const u8, args: anytype) !void {
pub fn debugNameFmt(self: *Module, target: IdResult, comptime fmt: []const u8, args: anytype) !void {
const name = try std.fmt.allocPrint(self.gpa, fmt, args);
defer self.gpa.free(name);
try self.debugName(target, name);
}
pub fn memberDebugName(self: *Module, target: IdResult, member: u32, name: []const u8) !void {
try self.sections.debug_names.emit(self.gpa, .OpMemberName, .{
.type = target,
.member = member,

7
src/link/SpirV.zig
View File

@ -110,6 +110,8 @@ pub fn updateFunc(self: *SpirV, module: *Module, func_index: InternPool.Index, a
}
const func = module.funcInfo(func_index);
const decl = module.declPtr(func.owner_decl);
log.debug("lowering function {s}", .{module.intern_pool.stringToSlice(decl.name)});
var decl_gen = codegen.DeclGen.init(self.base.allocator, module, &self.spv, &self.decl_link);
defer decl_gen.deinit();
@ -124,6 +126,9 @@ pub fn updateDecl(self: *SpirV, module: *Module, decl_index: Module.Decl.Index)
@panic("Attempted to compile for architecture that was disabled by build configuration");
}
const decl = module.declPtr(decl_index);
log.debug("lowering declaration {s}", .{module.intern_pool.stringToSlice(decl.name)});
var decl_gen = codegen.DeclGen.init(self.base.allocator, module, &self.spv, &self.decl_link);
defer decl_gen.deinit();
@ -212,7 +217,7 @@ pub fn flushModule(self: *SpirV, comp: *Compilation, prog_node: *std.Progress.No
fn writeCapabilities(spv: *SpvModule, target: std.Target) !void {
// TODO: Integrate with a hypothetical feature system
const caps: []const spec.Capability = switch (target.os.tag) {
.opencl => &.{ .Kernel, .Addresses, .Int8, .Int16, .Int64, .GenericPointer },
.opencl => &.{ .Kernel, .Addresses, .Int8, .Int16, .Int64, .Float64, .GenericPointer },
.glsl450 => &.{.Shader},
.vulkan => &.{.Shader},
else => unreachable, // TODO

23
test/behavior/array.zig
View File

@ -21,7 +21,6 @@ test "arrays" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var array: [5]u32 = undefined;
@ -49,7 +48,6 @@ fn getArrayLen(a: []const u32) usize {
test "array concat with undefined" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -89,7 +87,6 @@ test "array concat with tuple" {
test "array init with concat" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a = 'a';
var i: [4]u8 = [2]u8{ a, 'b' } ++ [2]u8{ 'c', 'd' };
@ -99,7 +96,6 @@ test "array init with concat" {
test "array init with mult" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a = 'a';
var i: [8]u8 = [2]u8{ a, 'b' } ** 4;
@ -141,7 +137,6 @@ test "array literal with specified size" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var array = [2]u8{ 1, 2 };
try expect(array[0] == 1);
@ -163,7 +158,6 @@ test "array len field" {
test "array with sentinels" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest(is_ct: bool) !void {
@ -201,7 +195,6 @@ test "nested arrays of strings" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const array_of_strings = [_][]const u8{ "hello", "this", "is", "my", "thing" };
for (array_of_strings, 0..) |s, i| {
@ -231,7 +224,6 @@ test "nested arrays of integers" {
test "implicit comptime in array type size" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var arr: [plusOne(10)]bool = undefined;
try expect(arr.len == 11);
@ -244,7 +236,6 @@ fn plusOne(x: u32) u32 {
test "single-item pointer to array indexing and slicing" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testSingleItemPtrArrayIndexSlice();
try comptime testSingleItemPtrArrayIndexSlice();
@ -288,7 +279,6 @@ test "anonymous list literal syntax" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -326,7 +316,6 @@ test "read/write through global variable array of struct fields initialized via
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -366,7 +355,6 @@ fn testArrayByValAtComptime(b: [2]u8) u8 {
test "comptime evaluating function that takes array by value" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const arr = [_]u8{ 1, 2 };
const x = comptime testArrayByValAtComptime(arr);
@ -378,7 +366,6 @@ test "comptime evaluating function that takes array by value" {
test "runtime initialize array elem and then implicit cast to slice" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var two: i32 = 2;
const x: []const i32 = &[_]i32{two};
@ -388,7 +375,6 @@ test "runtime initialize array elem and then implicit cast to slice" {
test "array literal as argument to function" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn entry(two: i32) !void {
@ -417,7 +403,6 @@ test "double nested array to const slice cast in array literal" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn entry(two: i32) !void {
@ -479,7 +464,6 @@ test "anonymous literal in array" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const Foo = struct {
@ -504,7 +488,6 @@ test "anonymous literal in array" {
test "access the null element of a null terminated array" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -522,7 +505,6 @@ test "type deduction for array subscript expression" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -620,7 +602,6 @@ test "type coercion of pointer to anon struct literal to pointer to array" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const U = union {
@ -659,7 +640,6 @@ test "tuple to array handles sentinel" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const a = .{ 1, 2, 3 };
@ -703,7 +683,6 @@ test "array of array agregate init" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a = [1]u32{11} ** 10;
var b = [1][10]u32{a} ** 2;
@ -777,6 +756,8 @@ test "array init with no result pointer sets field result types" {
}
test "runtime side-effects in comptime-known array init" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var side_effects: u4 = 0;
const init = [4]u4{
blk: {

9
test/behavior/basic.zig
View File

@ -330,7 +330,6 @@ const FnPtrWrapper = struct {
test "const ptr from var variable" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u64 = undefined;
var y: u64 = undefined;
@ -581,7 +580,7 @@ test "comptime cast fn to ptr" {
}
test "equality compare fn ptrs" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // Test passes but should not
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a = &emptyFn;
try expect(a == a);
@ -607,7 +606,6 @@ test "self reference through fn ptr field" {
test "global variable initialized to global variable array element" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(global_ptr == &gdt[0]);
}
@ -639,7 +637,6 @@ test "global constant is loaded with a runtime-known index" {
test "multiline string literal is null terminated" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const s1 =
\\one
@ -711,7 +708,6 @@ test "comptime manyptr concatenation" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const s = "epic";
const actual = manyptrConcat(s);
@ -1027,7 +1023,6 @@ comptime {
test "switch inside @as gets correct type" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: u32 = 0;
var b: [2]u32 = undefined;
@ -1136,8 +1131,6 @@ test "orelse coercion as function argument" {
}
test "runtime-known globals initialized with undefined" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
var array: [10]u32 = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var vp: [*]u32 = undefined;

4
test/behavior/bitcast.zig
View File

@ -271,6 +271,8 @@ test "comptime bitcast used in expression has the correct type" {
}
test "bitcast passed as tuple element" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo(args: anytype) !void {
try comptime expect(@TypeOf(args[0]) == f32);
@ -281,6 +283,8 @@ test "bitcast passed as tuple element" {
}
test "triple level result location with bitcast sandwich passed as tuple element" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo(args: anytype) !void {
try comptime expect(@TypeOf(args[0]) == f64);

1
test/behavior/bugs/10138.zig
View File

@ -5,7 +5,6 @@ test "registers get overwritten when ignoring return" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.cpu.arch != .x86_64 or builtin.os.tag != .linux) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const fd = open();
_ = write(fd, "a", 1);

1
test/behavior/bugs/10970.zig
View File

@ -7,7 +7,6 @@ test "breaking from a loop in an if statement" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var cond = true;
const opt = while (cond) {

2
test/behavior/bugs/11100.zig
View File

@ -9,7 +9,5 @@ pub fn do() bool {
}
test "bug" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(!do());
}

2
test/behavior/bugs/11165.zig
View File

@ -2,7 +2,6 @@ const builtin = @import("builtin");
test "bytes" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
a: u32,
@ -24,7 +23,6 @@ test "bytes" {
test "aggregate" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
a: u32,

1
test/behavior/bugs/11816.zig
View File

@ -4,7 +4,6 @@ const builtin = @import("builtin");
test {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u32 = 3;
const val: usize = while (true) switch (x) {

2
test/behavior/bugs/12025.zig
View File

@ -1,8 +1,6 @@
const builtin = @import("builtin");
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime var st = .{
.foo = &1,
.bar = &2,

2
test/behavior/bugs/12033.zig
View File

@ -2,8 +2,6 @@ const std = @import("std");
const builtin = @import("builtin");
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const string = "Hello!\x00World!";
try std.testing.expect(@TypeOf(string) == *const [13:0]u8);

2
test/behavior/bugs/12043.zig
View File

@ -7,8 +7,6 @@ fn foo(x: anytype) void {
ok = x;
}
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const x = &foo;
x(true);
try expect(ok);

1
test/behavior/bugs/12119.zig
View File

@ -9,7 +9,6 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const zerox32: u8x32 = [_]u8{0} ** 32;
const bigsum: u32x8 = @as(u32x8, @bitCast(zerox32));

8
test/behavior/bugs/12891.zig
View File

@ -7,29 +7,21 @@ test "issue12891" {
try std.testing.expect(i < f);
}
test "nan" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const f = comptime std.math.nan(f64);
var i: usize = 0;
try std.testing.expect(!(f < i));
}
test "inf" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const f = comptime std.math.inf(f64);
var i: usize = 0;
try std.testing.expect(f > i);
}
test "-inf < 0" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const f = comptime -std.math.inf(f64);
var i: usize = 0;
try std.testing.expect(f < i);
}
test "inf >= 1" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const f = comptime std.math.inf(f64);
var i: usize = 1;
try std.testing.expect(f >= i);

4
test/behavior/bugs/12928.zig
View File

@ -11,8 +11,6 @@ const B = extern struct {
};
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: *A = undefined;
try expect(@TypeOf(&a.value.a) == *volatile u32);
try expect(@TypeOf(&a.value.b) == *volatile i32);
@ -26,8 +24,6 @@ const D = extern union {
b: i32,
};
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var c: *C = undefined;
try expect(@TypeOf(&c.value.a) == *volatile u32);
try expect(@TypeOf(&c.value.b) == *volatile i32);

1
test/behavior/bugs/12984.zig
View File

@ -14,7 +14,6 @@ pub const CustomDraw = DeleagateWithContext(fn (?OnConfirm) void);
test "simple test" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var c: CustomDraw = undefined;
_ = c;

1
test/behavior/bugs/13113.zig
View File

@ -10,7 +10,6 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const foo = Foo{
.a = 1,

1
test/behavior/bugs/13159.zig
View File

@ -11,7 +11,6 @@ const Bar = packed struct {
test {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var foo = Bar.Baz.fizz;
try expect(foo == .fizz);

1
test/behavior/bugs/13285.zig
View File

@ -6,7 +6,6 @@ const Crasher = struct {
test {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: Crasher = undefined;
var crasher_ptr = &a;

2
test/behavior/bugs/14854.zig
View File

@ -2,8 +2,6 @@ const testing = @import("std").testing;
const builtin = @import("builtin");
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testing.expect(getGeneric(u8, getU8) == 123);
}

2
test/behavior/bugs/1500.zig
View File

@ -6,8 +6,6 @@ const A = struct {
const B = *const fn (A) void;
test "allow these dependencies" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: A = undefined;
var b: B = undefined;
if (false) {

2
test/behavior/bugs/15778.zig
View File

@ -6,7 +6,6 @@ test {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const a = @Vector(0, i32){};
const b = @Vector(0, i32){};
_ = a + b;
@ -18,7 +17,6 @@ test {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const a = @Vector(0, f32){};
const b = @Vector(0, f32){};
_ = a - b;

1
test/behavior/bugs/2622.zig
View File

@ -7,7 +7,6 @@ test "reslice of undefined global var slice" {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var mem: [100]u8 = [_]u8{0} ** 100;
buf = &mem;

2
test/behavior/bugs/3779.zig
View File

@ -8,7 +8,6 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
test "@tagName() returns a string literal" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));
@ -22,7 +21,6 @@ const ptr_error_name: [*:0]const u8 = error_name;
test "@errorName() returns a string literal" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));

1
test/behavior/bugs/4954.zig
View File

@ -8,7 +8,6 @@ test "crash" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var buf: [4096]u8 = undefined;
f(&buf);

1
test/behavior/bugs/5398.zig
View File

@ -22,7 +22,6 @@ test "assignment of field with padding" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
renderable = Renderable{
.mesh = Mesh{ .id = 0 },

1
test/behavior/bugs/5487.zig
View File

@ -13,5 +13,6 @@ test "crash" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
_ = io.multiWriter(.{writer()});
}

1
test/behavior/bugs/6456.zig
View File

@ -13,7 +13,6 @@ const text =
test "issue 6456" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime {
var fields: []const StructField = &[0]StructField{};

1
test/behavior/bugs/656.zig
View File

@ -14,7 +14,6 @@ test "optional if after an if in a switch prong of a switch with 2 prongs in an
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try foo(false, true);
}

2
test/behavior/bugs/7047.zig
View File

@ -15,8 +15,6 @@ fn S(comptime query: U) type {
}
test "compiler doesn't consider equal unions with different 'type' payload" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const s1 = S(U{ .T = u32 }).tag();
try std.testing.expectEqual(u32, s1);

2
test/behavior/bugs/7187.zig
View File

@ -3,8 +3,6 @@ const builtin = @import("builtin");
const expect = std.testing.expect;
test "miscompilation with bool return type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: usize = 1;
var y: bool = getFalse();
_ = y;

2
test/behavior/bugs/8277.zig
View File

@ -2,8 +2,6 @@ const std = @import("std");
const builtin = @import("builtin");
test "@sizeOf reified union zero-size payload fields" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime {
try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union {}))));
try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union { a: void }))));

1
test/behavior/bugs/828.zig
View File

@ -31,7 +31,6 @@ fn constCount(comptime cb: *const CountBy, comptime unused: u32) void {
test "comptime struct return should not return the same instance" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
//the first parameter must be passed by reference to trigger the bug
//a second parameter is required to trigger the bug

1
test/behavior/byval_arg_var.zig
View File

@ -5,7 +5,6 @@ var result: []const u8 = "wrong";
test "pass string literal byvalue to a generic var param" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
start();
blowUpStack(10);

1
test/behavior/call.zig
View File

@ -334,7 +334,6 @@ test "inline call preserves tail call" {
test "inline call doesn't re-evaluate non generic struct" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo(f: struct { a: u8, b: u8 }) !void {

1
test/behavior/call_tail.zig
View File

@ -46,6 +46,7 @@ test "arguments pointed to on stack into tailcall" {
}
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var data = [_]u64{ 1, 6, 2, 7, 1, 9, 3 };
base = @intFromPtr(&data);

37
test/behavior/cast.zig
View File

@ -403,7 +403,6 @@ test "peer type unsigned int to signed" {
test "expected [*c]const u8, found [*:0]const u8" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: [*:0]const u8 = "hello";
var b: [*c]const u8 = a;
@ -445,7 +444,6 @@ test "implicitly cast from T to anyerror!?T" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try castToOptionalTypeError(1);
try comptime castToOptionalTypeError(1);
@ -521,7 +519,6 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
test "implicit cast from *const [N]T to []const T" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testCastConstArrayRefToConstSlice();
try comptime testCastConstArrayRefToConstSlice();
@ -547,7 +544,6 @@ fn testCastConstArrayRefToConstSlice() !void {
test "peer type resolution: error and [N]T" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
try comptime expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
@ -709,7 +705,6 @@ test "peer type resolution: error set supersets" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a: error{ One, Two } = undefined;
const b: error{One} = undefined;
@ -739,7 +734,6 @@ test "peer type resolution: disjoint error sets" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a: error{ One, Two } = undefined;
const b: error{Three} = undefined;
@ -769,7 +763,6 @@ test "peer type resolution: error union and error set" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a: error{Three} = undefined;
const b: error{ One, Two }!u32 = undefined;
@ -803,7 +796,6 @@ test "peer type resolution: error union after non-error" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a: u32 = undefined;
const b: error{ One, Two }!u32 = undefined;
@ -863,7 +855,6 @@ test "peer cast *[0]T to []const T" {
test "peer cast *[N]T to [*]T" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var array = [4:99]i32{ 1, 2, 3, 4 };
var dest: [*]i32 = undefined;
@ -930,7 +921,6 @@ test "peer cast [N:x]T to [N]T" {
test "peer cast *[N:x]T to *[N]T" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -946,7 +936,6 @@ test "peer cast *[N:x]T to *[N]T" {
test "peer cast [*:x]T to [*]T" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -967,7 +956,6 @@ test "peer cast [:x]T to [*:x]T" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -988,7 +976,6 @@ test "peer cast [:x]T to [*:x]T" {
test "peer type resolution implicit cast to return type" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -1009,7 +996,6 @@ test "peer type resolution implicit cast to return type" {
test "peer type resolution implicit cast to variable type" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -1034,7 +1020,6 @@ test "variable initialization uses result locations properly with regards to the
test "cast between C pointer with different but compatible types" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo(arg: [*]c_ushort) u16 {
@ -1052,7 +1037,6 @@ test "cast between C pointer with different but compatible types" {
test "peer type resolve string lit with sentinel-terminated mutable slice" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var array: [4:0]u8 = undefined;
array[4] = 0; // TODO remove this when #4372 is solved
@ -1062,8 +1046,6 @@ test "peer type resolve string lit with sentinel-terminated mutable slice" {
}
test "peer type resolve array pointers, one of them const" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var array1: [4]u8 = undefined;
const array2: [5]u8 = undefined;
try comptime expect(@TypeOf(&array1, &array2) == []const u8);
@ -1071,8 +1053,6 @@ test "peer type resolve array pointers, one of them const" {
}
test "peer type resolve array pointer and unknown pointer" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const const_array: [4]u8 = undefined;
var array: [4]u8 = undefined;
var const_ptr: [*]const u8 = undefined;
@ -1092,8 +1072,6 @@ test "peer type resolve array pointer and unknown pointer" {
}
test "comptime float casts" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a = @as(comptime_float, @floatFromInt(1));
try expect(a == 1);
try expect(@TypeOf(a) == comptime_float);
@ -1140,8 +1118,6 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
}
test "compile time int to ptr of function" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try foobar(FUNCTION_CONSTANT);
}
@ -1156,6 +1132,7 @@ fn foobar(func: PFN_void) !void {
test "cast function with an opaque parameter" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) {
// https://github.com/ziglang/zig/issues/16845
@ -1340,8 +1317,6 @@ test "*const [N]null u8 to ?[]const u8" {
}
test "cast between [*c]T and ?[*:0]T on fn parameter" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const Handler = ?fn ([*c]const u8) callconv(.C) void;
fn addCallback(comptime handler: Handler) void {
@ -1381,7 +1356,6 @@ test "cast between *[N]void and []void" {
test "peer resolve arrays of different size to const slice" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(mem.eql(u8, boolToStr(true), "true"));
try expect(mem.eql(u8, boolToStr(false), "false"));
@ -1485,7 +1459,6 @@ test "cast compatible optional types" {
test "coerce undefined single-item pointer of array to error union of slice" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a = @as([*]u8, undefined)[0..0];
var b: error{a}![]const u8 = a;
@ -1495,7 +1468,6 @@ test "coerce undefined single-item pointer of array to error union of slice" {
test "pointer to empty struct literal to mutable slice" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: []i32 = &.{};
try expect(x.len == 0);
@ -1584,7 +1556,6 @@ test "bitcast packed struct with u0" {
test "optional pointer coerced to optional allowzero pointer" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var p: ?*u32 = undefined;
var q: ?*allowzero u32 = undefined;
@ -1594,8 +1565,6 @@ test "optional pointer coerced to optional allowzero pointer" {
}
test "single item pointer to pointer to array to slice" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: i32 = 1234;
try expect(@as([]const i32, @as(*[1]i32, &x))[0] == 1234);
const z1 = @as([]const i32, @as(*[1]i32, &x));
@ -1631,8 +1600,6 @@ test "@volatileCast without a result location" {
}
test "coercion from single-item pointer to @as to slice" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u32 = 1;
// Why the following line gets a compile error?
@ -2294,7 +2261,6 @@ test "cast builtins can wrap result in error union" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const S = struct {
const MyEnum = enum(u32) { _ };
@ -2501,6 +2467,7 @@ test "@intFromBool on vector" {
test "numeric coercions with undefined" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const from: i32 = undefined;
var to: f32 = from;

1
test/behavior/cast_int.zig
View File

@ -19,7 +19,6 @@ test "coerce i8 to i32 and @intCast back" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: i8 = -5;
var y: i32 = -5;

2
test/behavior/comptime_memory.zig
View File

@ -425,6 +425,8 @@ test "mutate entire slice at comptime" {
}
test "dereference undefined pointer to zero-bit type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const p0: *void = undefined;
try testing.expectEqual({}, p0.*);

2
test/behavior/defer.zig
View File

@ -5,8 +5,6 @@ const expectEqual = std.testing.expectEqual;
const expectError = std.testing.expectError;
test "break and continue inside loop inside defer expression" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
testBreakContInDefer(10);
comptime testBreakContInDefer(10);
}

3
test/behavior/empty_union.zig
View File

@ -9,8 +9,6 @@ test "switch on empty enum" {
}
test "switch on empty enum with a specified tag type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const E = enum(u8) {};
var e: E = undefined;
switch (e) {}
@ -18,7 +16,6 @@ test "switch on empty enum with a specified tag type" {
test "switch on empty auto numbered tagged union" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union(enum(u8)) {};
var u: U = undefined;

4
test/behavior/enum.zig
View File

@ -935,7 +935,6 @@ const Bar = enum { A, B, C, D };
test "enum literal casting to error union with payload enum" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var bar: error{B}!Bar = undefined;
bar = .B; // should never cast to the error set
@ -947,7 +946,6 @@ test "constant enum initialization with differing sizes" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try test3_1(test3_foo);
try test3_2(test3_bar);
@ -1054,7 +1052,6 @@ test "enum literal casting to optional" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var bar: ?Bar = undefined;
bar = .B;
@ -1141,7 +1138,6 @@ test "tag name functions are unique" {
test "size of enum with only one tag which has explicit integer tag type" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const E = enum(u8) { nope = 10 };
const S0 = struct { e: E };

16
test/behavior/error.zig
View File

@ -30,7 +30,6 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
test "error binary operator" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a = errBinaryOperatorG(true) catch 3;
const b = errBinaryOperatorG(false) catch 3;
@ -62,14 +61,12 @@ pub fn baz() anyerror!i32 {
test "error wrapping" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect((baz() catch unreachable) == 15);
}
test "unwrap simple value from error" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const i = unwrapSimpleValueFromErrorDo() catch unreachable;
try expect(i == 13);
@ -80,7 +77,6 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize {
test "error return in assignment" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
doErrReturnInAssignment() catch unreachable;
}
@ -103,7 +99,6 @@ test "syntax: optional operator in front of error union operator" {
test "widen cast integer payload of error union function call" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn errorable() !u64 {
@ -150,7 +145,6 @@ test "implicit cast to optional to error union to return result loc" {
}
test "fn returning empty error set can be passed as fn returning any error" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
entry();
comptime entry();
}
@ -243,7 +237,6 @@ fn testExplicitErrorSetCast(set1: Set1) !void {
test "comptime test error for empty error set" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testComptimeTestErrorEmptySet(1234);
try comptime testComptimeTestErrorEmptySet(1234);
@ -279,7 +272,6 @@ test "inferred empty error set comptime catch" {
}
test "error inference with an empty set" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const Struct = struct {
pub fn func() (error{})!usize {
@ -334,7 +326,6 @@ fn quux_1() !i32 {
test "error: Zero sized error set returned with value payload crash" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
_ = try foo3(0);
_ = try comptime foo3(0);
@ -434,7 +425,6 @@ test "nested error union function call in optional unwrap" {
test "return function call to error set from error union function" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn errorable() anyerror!i32 {
@ -670,7 +660,6 @@ test "peer type resolution of two different error unions" {
}
test "coerce error set to the current inferred error set" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo() !void {
var a = false;
@ -833,7 +822,6 @@ test "alignment of wrapping an error union payload" {
test "compare error union and error set" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: anyerror = error.Foo;
var b: anyerror!u32 = error.Bar;
@ -862,8 +850,6 @@ fn non_errorable() void {
}
test "catch within a function that calls no errorable functions" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
non_errorable();
}
@ -895,7 +881,6 @@ test "field access of anyerror results in smaller error set" {
test "optional error union return type" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo() ?anyerror!u32 {
@ -942,6 +927,7 @@ test "returning an error union containing a type with no runtime bits" {
test "try used in recursive function with inferred error set" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const Value = union(enum) {
values: []const @This(),

36
test/behavior/eval.zig
View File

@ -5,8 +5,6 @@ const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
test "compile time recursion" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(some_data.len == 21);
}
var some_data: [@as(usize, @intCast(fibonacci(7)))]u8 = undefined;
@ -74,7 +72,6 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {
test "constant expressions" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var array: [array_size]u8 = undefined;
try expect(@sizeOf(@TypeOf(array)) == 20);
@ -143,7 +140,6 @@ test "pointer to type" {
test "a type constructed in a global expression" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var l: List = undefined;
l.array[0] = 10;
@ -202,8 +198,6 @@ test "@setEvalBranchQuota" {
}
test "constant struct with negation" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(vertices[0].x == @as(f32, -0.6));
}
const Vertex = struct {
@ -308,8 +302,6 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
}
test "comptime iterate over fn ptr list" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(performFn('t', 1) == 6);
try expect(performFn('o', 0) == 1);
try expect(performFn('w', 99) == 99);
@ -348,7 +340,6 @@ fn doesAlotT(comptime T: type, value: usize) T {
test "@setEvalBranchQuota at same scope as generic function call" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(doesAlotT(u32, 2) == 2);
}
@ -385,8 +376,6 @@ test "zero extend from u0 to u1" {
}
test "return 0 from function that has u0 return type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo_zero() u0 {
return 0;
@ -417,8 +406,6 @@ var st_init_str_foo = StInitStrFoo{
};
test "inline for with same type but different values" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var res: usize = 0;
inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| {
var a: T = undefined;
@ -544,7 +531,6 @@ test "runtime 128 bit integer division" {
test "@tagName of @typeInfo" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const str = @tagName(@typeInfo(u8));
try expect(std.mem.eql(u8, str, "Int"));
@ -554,7 +540,6 @@ test "static eval list init" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(static_vec3.data[2] == 1.0);
try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0);
@ -586,7 +571,6 @@ test "inlined loop has array literal with elided runtime scope on first iteratio
test "ptr to local array argument at comptime" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime {
var bytes: [10]u8 = undefined;
@ -623,7 +607,6 @@ const hi1 = "hi";
const hi2 = hi1;
test "const global shares pointer with other same one" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try assertEqualPtrs(&hi1[0], &hi2[0]);
try comptime expect(&hi1[0] == &hi2[0]);
@ -659,8 +642,6 @@ pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type {
}
test "comptime function with mutable pointer is not memoized" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime {
var x: i32 = 1;
const ptr = &x;
@ -729,6 +710,7 @@ fn loopNTimes(comptime n: usize) void {
}
test "variable inside inline loop that has different types on different iterations" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testVarInsideInlineLoop(.{ true, @as(u32, 42) });
}
@ -752,7 +734,6 @@ test "array concatenation of function calls" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a = oneItem(3) ++ oneItem(4);
try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
@ -762,7 +743,6 @@ test "array multiplication of function calls" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a = oneItem(3) ** scalar(2);
try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));
@ -851,7 +831,6 @@ test "array multiplication sets the sentinel - value" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a = [2:7]u3{ 1, 6 };
var b = a ** 2;
@ -868,7 +847,6 @@ test "array multiplication sets the sentinel - pointer" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a = [2:7]u3{ 1, 6 };
var b = &a ** 2;
@ -1003,7 +981,6 @@ test "closure capture type of runtime-known var" {
test "comptime break passing through runtime condition converted to runtime break" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -1037,7 +1014,6 @@ test "comptime break to outer loop passing through runtime condition converted t
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -1109,7 +1085,6 @@ test "comptime break operand passing through runtime switch converted to runtime
test "no dependency loop for alignment of self struct" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -1147,7 +1122,6 @@ test "no dependency loop for alignment of self struct" {
test "no dependency loop for alignment of self bare union" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -1185,7 +1159,6 @@ test "no dependency loop for alignment of self bare union" {
test "no dependency loop for alignment of self tagged union" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -1376,7 +1349,6 @@ test "lazy value is resolved as slice operand" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const A = struct { a: u32 };
var a: [512]u64 = undefined;
@ -1434,7 +1406,6 @@ test "inline for inside a runtime condition" {
test "continue in inline for inside a comptime switch" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const arr = .{ 1, 2, 3 };
var count: u8 = 0;
@ -1500,7 +1471,6 @@ test "continue nested inline for loop in named block expr" {
test "x and false is comptime-known false" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const T = struct {
var x: u32 = 0;
@ -1528,7 +1498,6 @@ test "x and false is comptime-known false" {
test "x or true is comptime-known true" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const T = struct {
var x: u32 = 0;
@ -1558,7 +1527,6 @@ test "non-optional and optional array elements concatenated" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const array = [1]u8{'A'} ++ [1]?u8{null};
var index: usize = 0;
@ -1647,8 +1615,6 @@ test "result of nested switch assigned to variable" {
}
test "inline for loop of functions returning error unions" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const T1 = struct {
fn v() error{}!usize {
return 1;

3
test/behavior/floatop.zig
View File

@ -736,7 +736,6 @@ test "@ceil" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try comptime testCeil();
try testCeil();
@ -1053,7 +1052,6 @@ test "negation f128" {
test "eval @setFloatMode at compile-time" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const result = comptime fnWithFloatMode();
try expect(result == 1234.0);
@ -1089,7 +1087,6 @@ test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
inline for (.{ f16, f32, f64, f80, f128 }) |F| {
const pos = @as(F, 1) / @as(F, 0);

14
test/behavior/fn.zig
View File

@ -20,8 +20,6 @@ fn testLocVars(b: i32) void {
}
test "mutable local variables" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var zero: i32 = 0;
try expect(zero == 0);
@ -53,8 +51,6 @@ test "weird function name" {
}
test "assign inline fn to const variable" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a = inlineFn;
a();
}
@ -190,7 +186,6 @@ test "function with complex callconv and return type expressions" {
test "pass by non-copying value" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
}
@ -218,7 +213,6 @@ fn addPointCoordsVar(pt: anytype) !i32 {
test "pass by non-copying value as method" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var pt = Point2{ .x = 1, .y = 2 };
try expect(pt.addPointCoords() == 3);
@ -235,7 +229,6 @@ const Point2 = struct {
test "pass by non-copying value as method, which is generic" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var pt = Point3{ .x = 1, .y = 2 };
try expect(pt.addPointCoords(i32) == 3);
@ -253,7 +246,6 @@ const Point3 = struct {
test "pass by non-copying value as method, at comptime" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime {
var pt = Point2{ .x = 1, .y = 2 };
@ -396,8 +388,6 @@ test "function call with anon list literal - 2D" {
}
test "ability to give comptime types and non comptime types to same parameter" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
var x: i32 = 1;
@ -415,8 +405,6 @@ test "ability to give comptime types and non comptime types to same parameter" {
}
test "function with inferred error set but returning no error" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo() !void {}
};
@ -583,6 +571,8 @@ test "lazy values passed to anytype parameter" {
}
test "pass and return comptime-only types" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn returnNull(comptime x: @Type(.Null)) @Type(.Null) {
return x;

4
test/behavior/for.zig
View File

@ -257,7 +257,6 @@ test "for loop with else branch" {
test "count over fixed range" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var sum: usize = 0;
for (0..6) |i| {
@ -270,7 +269,6 @@ test "count over fixed range" {
test "two counters" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var sum: usize = 0;
for (0..10, 10..20) |i, j| {
@ -318,7 +316,6 @@ test "slice and two counters, one is offset and one is runtime" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const slice: []const u8 = "blah";
var start: usize = 0;
@ -406,7 +403,6 @@ test "inline for with slice as the comptime-known" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const comptime_slice = "hello";
var runtime_i: usize = 3;

15
test/behavior/generics.zig
View File

@ -55,7 +55,6 @@ test "fn with comptime args" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(gimmeTheBigOne(1234, 5678) == 5678);
try expect(shouldCallSameInstance(34, 12) == 34);
@ -66,7 +65,6 @@ test "anytype params" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(max_i32(12, 34) == 34);
try expect(max_f64(1.2, 3.4) == 3.4);
@ -91,7 +89,6 @@ fn max_f64(a: f64, b: f64) f64 {
test "type constructed by comptime function call" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var l: SimpleList(10) = undefined;
l.array[0] = 10;
@ -115,7 +112,6 @@ test "function with return type type" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var list: List(i32) = undefined;
var list2: List(i32) = undefined;
@ -147,8 +143,6 @@ fn GenericDataThing(comptime count: isize) type {
}
test "use generic param in generic param" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(aGenericFn(i32, 3, 4) == 7);
}
fn aGenericFn(comptime T: type, comptime a: T, b: T) T {
@ -178,7 +172,6 @@ test "generic fn keeps non-generic parameter types" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const A = 128;
@ -254,7 +247,6 @@ test "generic function instantiation turns into comptime call" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -288,6 +280,7 @@ test "generic function instantiation turns into comptime call" {
test "generic function with void and comptime parameter" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct { x: i32 };
const namespace = struct {
@ -304,7 +297,6 @@ test "generic function with void and comptime parameter" {
test "anonymous struct return type referencing comptime parameter" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
pub fn extraData(comptime T: type, index: usize) struct { data: T, end: usize } {
@ -405,8 +397,6 @@ test "generic struct as parameter type" {
}
test "slice as parameter type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn internComptimeString(comptime str: []const u8) *const []const u8 {
return &struct {
@ -421,8 +411,6 @@ test "slice as parameter type" {
}
test "null sentinel pointer passed as generic argument" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest(a: anytype) !void {
try std.testing.expect(@intFromPtr(a) == 8);
@ -433,7 +421,6 @@ test "null sentinel pointer passed as generic argument" {
test "generic function passed as comptime argument" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doMath(comptime f: fn (type, i32, i32) error{Overflow}!i32, a: i32, b: i32) !void {

3
test/behavior/inline_switch.zig
View File

@ -47,7 +47,6 @@ test "inline switch unions" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: U = .a;
switch (x) {
@ -141,8 +140,6 @@ test "inline else int all values" {
}
test "inline switch capture is set when switch operand is comptime known" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U2 = union(enum) {
a: u32,
};

5
test/behavior/math.zig
View File

@ -1020,7 +1020,6 @@ test "@subWithOverflow" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
{
var a: u8 = 1;
@ -1146,8 +1145,6 @@ test "overflow arithmetic with u0 values" {
}
test "allow signed integer division/remainder when values are comptime-known and positive or exact" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(5 / 3 == 1);
try expect(-5 / -3 == 1);
try expect(-6 / 3 == -2);
@ -1289,6 +1286,8 @@ fn testShrExact(x: u8) !void {
}
test "shift left/right on u0 operand" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
var x: u0 = 0;

2
test/behavior/maximum_minimum.zig
View File

@ -200,7 +200,6 @@ test "@min/@max on comptime_int" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const min = @min(1, 2, -2, -1);
const max = @max(1, 2, -2, -1);
@ -257,7 +256,6 @@ test "@min/@max notices bounds from types when comptime-known value is undef" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u32 = 1_000_000;
const y: u16 = undefined;

2
test/behavior/optional.zig
View File

@ -500,6 +500,8 @@ test "cast slice to const slice nested in error union and optional" {
}
test "variable of optional of noreturn" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var null_opv: ?noreturn = null;
try std.testing.expectEqual(@as(?noreturn, null), null_opv);
}

9
test/behavior/pointers.zig
View File

@ -125,7 +125,6 @@ fn testDerefPtrOneVal() !void {
}
test "peer type resolution with C pointers" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var ptr_one: *u8 = undefined;
var ptr_many: [*]u8 = undefined;
var ptr_c: [*c]u8 = undefined;
@ -141,7 +140,6 @@ test "peer type resolution with C pointers" {
}
test "peer type resolution with C pointer and const pointer" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var ptr_c: [*c]u8 = undefined;
const ptr_const: u8 = undefined;
try expect(@TypeOf(ptr_c, &ptr_const) == [*c]const u8);
@ -314,7 +312,6 @@ test "allow any sentinel" {
test "pointer sentinel with enums" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const Number = enum {
@ -336,7 +333,6 @@ test "pointer sentinel with optional element" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -353,7 +349,6 @@ test "pointer sentinel with +inf" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -374,7 +369,6 @@ test "pointer to array at fixed address" {
}
test "pointer arithmetic affects the alignment" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
{
var ptr: [*]align(8) u32 = undefined;
var x: usize = 1;
@ -430,7 +424,6 @@ test "indexing array with sentinel returns correct type" {
test "element pointer to slice" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -453,7 +446,6 @@ test "element pointer to slice" {
test "element pointer arithmetic to slice" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -478,7 +470,6 @@ test "element pointer arithmetic to slice" {
test "array slicing to slice" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {

11
test/behavior/slice.zig
View File

@ -29,7 +29,6 @@ comptime {
test "slicing" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var array: [20]i32 = undefined;
@ -122,7 +121,6 @@ test "slice of type" {
test "generic malloc free" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a = memAlloc(u8, 10) catch unreachable;
memFree(u8, a);
@ -303,7 +301,6 @@ test "slice type with custom alignment" {
test "obtaining a null terminated slice" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
// here we have a normal array
var buf: [50]u8 = undefined;
@ -346,7 +343,6 @@ test "empty array to slice" {
test "@ptrCast slice to pointer" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -572,7 +568,6 @@ test "slice syntax resulting in pointer-to-array" {
test "slice pointer-to-array null terminated" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime {
var array = [5:0]u8{ 1, 2, 3, 4, 5 };
@ -626,7 +621,6 @@ test "type coercion of pointer to anon struct literal to pointer to slice" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const U = union {
@ -714,7 +708,6 @@ test "slice sentinel access at comptime" {
test "slicing array with sentinel as end index" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn do() !void {
@ -733,7 +726,6 @@ test "slicing array with sentinel as end index" {
test "slicing slice with sentinel as end index" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn do() !void {
@ -762,8 +754,6 @@ test "slice len modification at comptime" {
}
test "slice field ptr const" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const const_slice: []const u8 = "string";
const const_ptr_const_slice = &const_slice;
@ -777,7 +767,6 @@ test "slice field ptr const" {
test "slice field ptr var" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var var_slice: []const u8 = "string";

25
test/behavior/struct.zig
View File

@ -109,7 +109,6 @@ fn testMutation(foo: *StructFoo) void {
test "struct byval assign" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var foo1: StructFoo = undefined;
var foo2: StructFoo = undefined;
@ -129,14 +128,14 @@ test "call struct static method" {
const should_be_11 = StructWithNoFields.add(5, 6);
test "invoke static method in global scope" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(should_be_11 == 11);
}
const empty_global_instance = StructWithNoFields{};
test "return empty struct instance" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
_ = returnEmptyStructInstance();
}
fn returnEmptyStructInstance() StructWithNoFields {
@ -253,7 +252,6 @@ test "usingnamespace within struct scope" {
test "struct field init with catch" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -331,6 +329,7 @@ const VoidStructFieldsFoo = struct {
test "return empty struct from fn" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
_ = testReturnEmptyStructFromFn();
}
@ -364,8 +363,6 @@ test "self-referencing struct via array member" {
}
test "empty struct method call" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const es = EmptyStruct{};
try expect(es.method() == 1234);
}
@ -550,7 +547,6 @@ test "implicit cast packed struct field to const ptr" {
test "zero-bit field in packed struct" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = packed struct {
x: u10,
@ -893,6 +889,8 @@ test "anonymous struct literal syntax" {
}
test "fully anonymous struct" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
try dump(.{
@ -915,6 +913,8 @@ test "fully anonymous struct" {
}
test "fully anonymous list literal" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
@ -942,8 +942,6 @@ test "tuple assigned to variable" {
}
test "comptime struct field" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; // TODO
@ -981,7 +979,6 @@ test "struct with union field" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const Value = struct {
ref: u32 = 2,
@ -1432,8 +1429,6 @@ test "struct field has a pointer to an aligned version of itself" {
}
test "struct has only one reference" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn optionalStructParam(_: ?struct { x: u8 }) void {}
fn errorUnionStructParam(_: error{}!struct { x: u8 }) void {}
@ -1503,7 +1498,6 @@ test "discarded struct initialization works as expected" {
test "function pointer in struct returns the struct" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const A = struct {
const A = @This();
@ -1553,7 +1547,6 @@ test "optional field init with tuple" {
test "if inside struct init inside if" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const MyStruct = struct { x: u32 };
const b: u32 = 5;
@ -1715,6 +1708,8 @@ test "extern struct field pointer has correct alignment" {
}
test "packed struct field in anonymous struct" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const T = packed struct {
f1: bool = false,
};
@ -1740,6 +1735,8 @@ test "struct init with no result pointer sets field result types" {
}
test "runtime side-effects in comptime-known struct init" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var side_effects: u4 = 0;
const S = struct { a: u4, b: u4, c: u4, d: u4 };
const init = S{

12
test/behavior/switch.zig
View File

@ -232,7 +232,6 @@ test "switch prong with variable" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 });
try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 });
@ -257,7 +256,6 @@ test "switch on enum using pointer capture" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testSwitchEnumPtrCapture();
try comptime testSwitchEnumPtrCapture();
@ -318,7 +316,6 @@ test "switch on union with some prongs capturing" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const X = union(enum) {
a,
@ -355,7 +352,6 @@ test "switch on const enum with var" {
test "anon enum literal used in switch on union enum" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const Foo = union(enum) {
a: i32,
@ -394,7 +390,6 @@ fn switchWithUnreachable(x: i32) i32 {
test "capture value of switch with all unreachable prongs" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const x = return_a_number() catch |err| switch (err) {
else => unreachable,
@ -408,7 +403,6 @@ fn return_a_number() anyerror!i32 {
test "switch on integer with else capturing expr" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -498,7 +492,6 @@ test "switch prongs with error set cases make a new error set type for capture v
test "return result loc and then switch with range implicit casted to error union" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -539,7 +532,6 @@ test "switch prongs with cases with identical payload types" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const Union = union(enum) {
A: usize,
@ -706,8 +698,6 @@ test "switch item sizeof" {
}
test "comptime inline switch" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union(enum) { a: type, b: type };
const value = comptime blk: {
var u: U = .{ .a = u32 };
@ -799,6 +789,8 @@ test "inline switch range that includes the maximum value of the switched type"
}
test "nested break ignores switch conditions and breaks instead" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn register_to_address(ident: []const u8) !u8 {
const reg: u8 = if (std.mem.eql(u8, ident, "zero")) 0x00 else blk: {

1
test/behavior/this.zig
View File

@ -27,7 +27,6 @@ test "this refer to module call private fn" {
test "this refer to container" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var pt: Point(i32) = undefined;
pt.x = 12;

2
test/behavior/translate_c_macros.zig
View File

@ -233,6 +233,8 @@ test "@typeInfo on @cImport result" {
}
test "Macro that uses Long type concatenation casting" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect((@TypeOf(h.X)) == c_long);
try expectEqual(h.X, @as(c_long, 10));
}

2
test/behavior/try.zig
View File

@ -24,8 +24,6 @@ fn returnsTen() anyerror!i32 {
}
test "try without vars" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const result1 = if (failIfTrue(true)) 1 else |_| @as(i32, 2);
try expect(result1 == 2);

3
test/behavior/tuple.zig
View File

@ -289,7 +289,6 @@ test "coerce tuple to tuple" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const T = std.meta.Tuple(&.{u8});
const S = struct {
@ -304,7 +303,6 @@ test "tuple type with void field" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const T = std.meta.Tuple(&[_]type{void});
const x = T{{}};
@ -343,7 +341,6 @@ test "zero sized struct in tuple handled correctly" {
test "tuple type with void field and a runtime field" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const T = std.meta.Tuple(&[_]type{ usize, void });
var t: T = .{ 5, {} };

5
test/behavior/type_info.zig
View File

@ -160,7 +160,6 @@ test "type info: error set, error union info, anyerror" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testErrorSet();
try comptime testErrorSet();
@ -192,7 +191,6 @@ test "type info: error set single value" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const TestSet = error.One;
@ -206,7 +204,6 @@ test "type info: error set merged" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const TestSet = error{ One, Two } || error{Three};
@ -222,7 +219,6 @@ test "type info: enum info" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testEnum();
try comptime testEnum();
@ -533,7 +529,6 @@ test "Struct.is_tuple for anon list literal" {
test "Struct.is_tuple for anon struct literal" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const info = @typeInfo(@TypeOf(.{ .a = 0 }));
try expect(!info.Struct.is_tuple);

3
test/behavior/type_info_only_pub_decls.zig
View File

@ -1,3 +1,4 @@
const builtin = @import("builtin");
const std = @import("std");
const other = struct {
const std = @import("std");
@ -14,6 +15,8 @@ const other = struct {
};
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const ti = @typeInfo(other);
const decls = ti.Struct.decls;

2
test/behavior/undefined.zig
View File

@ -48,7 +48,6 @@ test "assign undefined to struct" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime {
var foo: Foo = undefined;
@ -66,7 +65,6 @@ test "assign undefined to struct with method" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime {
var foo: Foo = undefined;

1
test/behavior/underscore.zig
View File

@ -8,7 +8,6 @@ test "ignore lval with underscore" {
test "ignore lval with underscore (while loop)" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
while (optionalReturnError()) |_| {
while (optionalReturnError()) |_| {

30
test/behavior/union.zig
View File

@ -14,7 +14,6 @@ test "basic unions with floats" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var foo = FooWithFloats{ .int = 1 };
try expect(foo.int == 1);
@ -30,7 +29,6 @@ test "init union with runtime value - floats" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var foo: FooWithFloats = undefined;
@ -42,7 +40,6 @@ test "basic unions" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var foo = Foo{ .int = 1 };
try expect(foo.int == 1);
@ -61,7 +58,6 @@ test "init union with runtime value" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var foo: Foo = undefined;
@ -172,7 +168,6 @@ test "constant tagged union with payload" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var empty = TaggedUnionWithPayload{ .Empty = {} };
var full = TaggedUnionWithPayload{ .Full = 13 };
@ -342,7 +337,6 @@ test "constant packed union" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }});
}
@ -453,7 +447,6 @@ test "global union with single field is correctly initialized" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
glbl = Foo1{
.f = @typeInfo(Foo1).Union.fields[0].type{ .x = 123 },
@ -500,7 +493,6 @@ test "union initializer generates padding only if needed" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union(enum) {
A: u24,
@ -513,7 +505,6 @@ test "union initializer generates padding only if needed" {
test "runtime tag name with single field" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union(enum) {
A: i32,
@ -590,7 +581,6 @@ test "tagged union as return value" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
switch (returnAnInt(13)) {
TaggedFoo.One => |value| try expect(value == 13),
@ -635,7 +625,6 @@ test "union(enum(u32)) with specified and unspecified tag values" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try comptime expect(Tag(Tag(MultipleChoice2)) == u32);
try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });
@ -673,7 +662,6 @@ test "switch on union with only 1 field" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var r: PartialInst = undefined;
r = PartialInst.Compiled;
@ -702,7 +690,6 @@ const PartialInstWithPayload = union(enum) {
test "union with only 1 field casted to its enum type which has enum value specified" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const Literal = union(enum) {
Number: f64,
@ -787,7 +774,6 @@ test "return union init with void payload" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn entry() !void {
@ -841,7 +827,6 @@ test "@unionInit can modify a union type" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const UnionInitEnum = union(enum) {
Boolean: bool,
@ -865,7 +850,6 @@ test "@unionInit can modify a pointer value" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const UnionInitEnum = union(enum) {
Boolean: bool,
@ -922,7 +906,6 @@ test "anonymous union literal syntax" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const Number = union {
@ -1014,7 +997,6 @@ test "cast from pointer to anonymous struct to pointer to union" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const U = union(enum) {
@ -1046,7 +1028,6 @@ test "switching on non exhaustive union" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const E = enum(u8) {
@ -1179,7 +1160,6 @@ test "union with no result loc initiated with a runtime value" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union {
a: u32,
@ -1196,7 +1176,6 @@ test "union with a large struct field" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
a: [8]usize,
@ -1230,7 +1209,6 @@ test "union tag is set when initiated as a temporary value at runtime" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union(enum) {
a,
@ -1268,7 +1246,6 @@ test "return an extern union from C calling convention" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const namespace = struct {
const S = extern struct {
@ -1299,7 +1276,6 @@ test "noreturn field in union" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union(enum) {
a: u32,
@ -1351,7 +1327,6 @@ test "@unionInit uses tag value instead of field index" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const E = enum(u8) {
b = 255,
@ -1480,7 +1455,6 @@ test "no dependency loop when function pointer in union returns the union" {
test "union reassignment can use previous value" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union {
a: u32,
@ -1532,7 +1506,6 @@ test "reinterpreting enum value inside packed union" {
test "access the tag of a global tagged union" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union(enum) {
a,
@ -1544,7 +1517,6 @@ test "access the tag of a global tagged union" {
test "coerce enum literal to union in result loc" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union(enum) {
a,
@ -1669,6 +1641,8 @@ test "packed union field pointer has correct alignment" {
}
test "union with 128 bit integer" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const ValueTag = enum { int, other };
const Value3 = union(ValueTag) {

9
test/behavior/var_args.zig
View File

@ -14,6 +14,8 @@ fn add(args: anytype) i32 {
}
test "add arbitrary args" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
try expect(add(.{@as(i32, 1234)}) == 1234);
try expect(add(.{}) == 0);
@ -24,12 +26,15 @@ fn readFirstVarArg(args: anytype) void {
}
test "send void arg to var args" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
readFirstVarArg(.{{}});
}
test "pass args directly" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234);
@ -82,11 +87,15 @@ fn foo2(args: anytype) bool {
}
test "array of var args functions" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(foos[0](.{}));
try expect(!foos[1](.{}));
}
test "pass zero length array to var args param" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
doNothingWithFirstArg(.{""});
}

2
test/behavior/vector.zig
View File

@ -240,7 +240,6 @@ test "peer type resolution with coercible element types" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -1469,7 +1468,6 @@ test "boolean vector with 2 or more booleans" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
// TODO: try removing this after <https://github.com/ziglang/zig/issues/13782>:
if (!(builtin.os.tag == .linux and builtin.cpu.arch == .x86_64)) return;

15
test/behavior/while.zig
View File

@ -50,8 +50,6 @@ test "while with continue expression" {
}
test "while with else" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var sum: i32 = 0;
var i: i32 = 0;
var got_else: i32 = 0;
@ -79,8 +77,6 @@ fn getNumberOrNull() ?i32 {
}
test "continue outer while loop" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
testContinueOuter();
comptime testContinueOuter();
}
@ -127,7 +123,6 @@ test "while copies its payload" {
test "continue and break" {
if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try runContinueAndBreakTest();
try expect(continue_and_break_counter == 8);
@ -149,7 +144,6 @@ fn runContinueAndBreakTest() !void {
test "while with optional as condition" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
numbers_left = 10;
var sum: i32 = 0;
@ -162,7 +156,6 @@ test "while with optional as condition" {
test "while with optional as condition with else" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
numbers_left = 10;
var sum: i32 = 0;
@ -223,7 +216,6 @@ test "while on optional with else result follow break prong" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const result = while (returnOptional(10)) |value| {
break value;
@ -251,8 +243,6 @@ fn returnTrue() bool {
}
test "return with implicit cast from while loop" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
returnWithImplicitCastFromWhileLoopTest() catch unreachable;
}
fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
@ -263,7 +253,6 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
test "while on error union with else result follow else prong" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const result = while (returnError()) |value| {
break value;
@ -273,7 +262,6 @@ test "while on error union with else result follow else prong" {
test "while on error union with else result follow break prong" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const result = while (returnSuccess(10)) |value| {
break value;
@ -319,7 +307,6 @@ test "while error 2 break statements and an else" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn entry(opt_t: anyerror!bool, f: bool) !void {
@ -345,8 +332,6 @@ test "continue inline while loop" {
}
test "else continue outer while" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var i: usize = 0;
while (true) {
i += 1;