Write idiomatic Elixir ExUnit tests — tests knowledge of Elixir testing conventions
Write an ExUnit test module for the following Elixir function: ```elixir defmodule StringUtils do @doc """ Truncates a string to at most `max_len` characters. If truncated, appends `suffix` (default: "..."). Returns the original string if it is already within `max_len`. Raises ArgumentError if max_len is negative. """ @spec truncate(String.t(), non_neg_integer(), String.t()) :: String.t() def truncate(str, max_len, suffix \\ "...") end ``` Requirements: - Module name: `StringUtilsTest`, `use ExUnit.Case` - Use `describe` blocks to group related cases - At least 2 `describe` blocks: one for happy path, one for edge/error cases - At least 8 test cases total covering: string shorter than limit, exact length, longer string (suffix appended), empty string, custom suffix, max_len of 0, negative max_len (should raise), unicode string - Use `assert`, `assert_raise`, and pattern matching appropriately - Add at least one doctest-style `## Examples` in a module comment showing usage
Do the 8+ tests cover all specified cases with correct expected values? Does `assert_raise ArgumentError` correctly test the negative max_len case? Are unicode string lengths handled via `String.length/1`, not `byte_size/1`?
Are `describe` blocks used to group related tests logically? Are test names written as plain English specs ('truncates when string exceeds limit')? Is pattern matching used where it adds clarity (e.g. matching on {:ok, _} if the API returns tuples)? Is the module correctly structured with `use ExUnit.Case`?
Are describe block labels and test names readable as a spec? Is the module-level Examples comment present and accurate? Does the overall file read like idiomatic Elixir test documentation?
# Comprehensive, well-organized tests with correct unicode/String.length usage and proper assert_raise, though the exact behavior for max_len=0/suffix-longer-than-max_len cases is somewhat assumption-based since no implementation was given, and the added `doctest StringUtils` call is likely a no-op since the actual module lacks doc examples.
inspect full trace →# patched after judge fix
inspect full trace →# Covers all required scenarios and uses assert_raise/describe blocks well, but contains an internal inconsistency (empty string + custom suffix test contradicts its own assumed implementation) and the doctest Examples section has several numerically incorrect examples (e.g. 'hello world',7 => 'hello...' exceeds max_len), undermining correctness and documentation accuracy despite good structural style.
inspect full trace →# Good coverage of required scenarios and correct assert_raise usage, but the custom-suffix expected value ('he~') is inconsistent with the truncation formula implied by the default-suffix test ('he...'), suggesting a copy-paste error, and the zero-length/negative-length assumptions are unverified given no reference implementation; the 'Examples' section is written as plain comments rather than a proper @moduledoc, weakening the documentation requirement.
inspect full trace →# The test suite is well-organized with proper describe blocks and required assertion types, but the expected values are internally inconsistent (the moduledoc doctest for 'Elixir'/4 yields a 7-char result violating 'at most max_len', while the 'abcdefghij'/5 test assumes suffix length is subtracted from max_len, and the unicode test miscalculates even by that same rule) — no single implementation of truncate could satisfy all these assertions simultaneously, which is a serious correctness flaw; also the claim of 'pattern matching' usage is inaccurate since none is actually used in the tests.
inspect full trace →