} else if (Type element_type =
                     GetFixedElementType(attr_key.getValue(), builder)) {
        output_types->push_back(UnrankedTensorType::get(element_type));
      } else {
        emitError(loc) << "type " << attr_key.getValue()
                       << " can't be resolved for the signature of the op";
        return failure();
      }
      continue;
    }

      if (!llvm::is_contained(device_var_reads_indices, it.index()) &&
          !llvm::is_contained(device_var_updates_indices, it.index())) {
        return execute_launch.GetBody().front().emitError("operand #")
               << it.index()
               << " is a resource that was neither read nor written to; this "
                  "resource potentially failed to be hoisted";
      }
    }
  }

        std::string err_msg;
        llvm::raw_string_ostream os(err_msg);
        for (unsigned i = 0; i < op->getNumResults(); ++i)
          os << " " << i << ":" << results.GetConstraint(op->getResult(i));
        op->emitError(llvm::formatv(
            "failed to propagate results constraints:{0}", os.str()));
      }
      return failure();
    }

    // Update results constraints based on inferred operands constraints.

    tile_assignment_rank -= sharding->last_tile_dims_size();

    if (tensor_rank < tile_assignment_rank) {
      if (partitioned_op) {
        partitioned_op->emitError()
            << "tensor of type " << ranked_type << " (rank=" << tensor_rank
            << ") sharded in " << (tile_assignment_rank - tensor_rank)
            << " extra dimension(s) by: " << sharding->DebugString();

    if (HasWeightOnlyPtqMethod(op) && !IsHybridQuantizedOp(op)) {
      return failure();
    }

    func::FuncOp entry_func_op = GetEntryFuncOp(op, SymbolTable(module_op));
    if (!entry_func_op) {
      op->emitError("Failed to find a valid entry function.");
      return failure();
    }
    Method quantization_method = GetQuantizationMethodOrDefault(op);
    return FuncBodyRewritePatternT(enable_per_channel_quantized_weight_)

    const llvm::SmallPtrSetImpl<Block*>& control_flow_blocks, bool is_clone) {
  MLIRContext* context = module.getContext();
  if (!llvm::hasSingleElement(func.getBody()))
    return func.emitError()
           << "'" << FuncOp::getOperationName()
           << "' ops with more than one block are not supported";

  bool rewrite_block =
      is_clone || (!func.isPublic() && !func.symbolKnownUseEmpty(module));

        if (Operation* quantize_op = dyn_cast_or_null<QuantizeOpT>(
                *quantized_op->getResult(i).getUsers().begin())) {
          result = quantize_op->getResult(0);
        } else {
          quantized_op->emitError()
              << "Output[" << i
              << "] is expected to have only one user [QUANTIZE]";
          return;
        }
      } else {
        result = quantized_op->getResult(i);
      }

		// resulting error should be an exec.ExitError without additional wrapping.
		if _, ok := err.(*exec.ExitError); !ok {
			t.Errorf("Wait error = %v; want *exec.ExitError", err)
		}
	})

	// If Cancel returns ErrProcessDone but the process is not actually done
	// (and has to be killed), Wait should report the usual SIGKILL ExitError,
	// not the error from Cancel.

		// set it to nil to prevent awaitGoroutines from blocking on it.
		c.goroutineErr = nil
	}

	resultc <- ctxResult{err: err}
}

// An ExitError reports an unsuccessful exit by a command.
type ExitError struct {
	*os.ProcessState

	// Stderr holds a subset of the standard error output from the
	// Cmd.Output method if standard error was not otherwise being
	// collected.
	//

	_, err = csiMapper.SetUpDevice()
	if err == nil {
		t.Errorf("test should fail, but no error occurred")
	} else if reflect.TypeOf(transientError) != reflect.TypeOf(err) {
		t.Fatalf("expected exitError type: %v got: %v (%v)", reflect.TypeOf(transientError), reflect.TypeOf(err), err)
	}
}

func TestBlockMapperMapPodDevice(t *testing.T) {
	plug, tmpDir := newTestPlugin(t, nil)
	defer os.RemoveAll(tmpDir)