Scripting API
For developers who need mock data at runtime - automated testing, procedural content, live dashboards, or CI pipelines - MockMagic provides a clean static API. Every feature available in the Editor window is also available from code.
Assembly reference: Add a reference to the MockMagic assembly definition in your .asmdef file, or place your scripts in a folder without an assembly definition.
Namespace: using MockMagic;
Simple Data from Code
The Mock static class provides one method per data type, plus batch variants.
Single Values
using MockMagic;
string name = Mock.Name(); // "Sarah Johnson"
string email = Mock.Email(); // "marcus.patel@outlook.com"
string phone = Mock.Phone(); // "+1 (425) 738-2914"
int age = Mock.Age(); // 34
string address = Mock.FullAddress(); // "1847 Oak Ave, Seattle, WA 98101"
string guid = Mock.Guid(); // "a3f8b2c1-d4e5-4f6a-8b9c-0d1e2f3a4b5c"
float pct = Mock.Percentage(); // 87.45
bool flag = Mock.Boolean(); // true
string lorem = Mock.LoremIpsum(20); // 20 words of lorem ipsum
UnityEngine.Color color = Mock.Color();// Random RGB color
Batch Values
Every single-value method has a batch counterpart that returns an array:
string[] names = Mock.Names(50);
string[] emails = Mock.Emails(100);
int[] ages = Mock.Ages(25);
string[] cities = Mock.Cities(10);
Generic Dispatch
Use Mock.Generate() when the data type is determined at runtime:
// Single value
string value = Mock.Generate(SimpleDataType.Email);
// Batch
string[] values = Mock.Generate(SimpleDataType.Email, 50);
Random Enum Values
Generate random values of any enum type:
MyEnum randomValue = Mock.Enum<MyEnum>();
MyEnum[] randomValues = Mock.Enums<MyEnum>(10);
ID Counter
Mock.Id() returns auto-incrementing integers. Reset with:
Mock.ResetIdCounter(0); // Next Id() call returns 0
Determinism & Seeding
Call Mock.Seed(int) once at the top of a deterministic run; pair it with Mock.UseDateReference(...) so date-, time- and timestamp-based helpers stay reproducible across days.
Mock.Seed(12345); // seeds MockRandom + UnityEngine.Random
Mock.UseDateReference(new DateTime(2026, 1, 1)); // freeze "now" for date helpers
string a = Mock.Email(); // reproducible
string b = Mock.Date(); // reproducible
Mock.ResetSeed(); // back to wall-clock randomness
Format & Hash Helpers
Shape any string with a tiny pattern language: ‘#’= digit, ‘?’= lowercase letter, ‘*’= alphanumeric, ‘\’= escape the next character. Phone, SSN, ZIP and MAC helpers all use it internally.
string sku = Mock.Format("AB-####-???"); // "AB-2741-xqp"
string sha = Mock.Hash(); // 40-char hex (SHA-1 length)
string code = Mock.AlphaNumeric(8); // "k4j9pq7m"
string tag = Mock.Letters(5, upperCase: true);
Template Tokens & Custom Generators
Every SimpleDataType is a built-in token. Unknown tokens are left in place so they're easy to spot during debugging. Register your own tokens - or full typed generators - to extend the system without forking the package; use Mock.HasToken and Mock.UnregisterToken for registry checks and cleanup.
string row = Mock.Parse("{{firstName}} <{{email}}> id={{unique}}");
Mock.RegisterToken("orderRef", () => "ORD-" + Mock.Format("######"));
Mock.RegisterGenerator<int>("score", () => MockRandom.Range(1, 101));
int s = Mock.Get<int>("score");
string r = Mock.Parse("Reference: {{orderRef}}");
Probabilistic Nulls
Drop-in nullability for stress-testing consumers. The same extension set also provides seeded list helpers such as PickRandom() and Shuffle():
string maybeAddress = Mock.FullAddress().OrNull(0.3f); // reference types
int? maybeAge = Mock.Age().OrNullable(0.2f); // value types -> Nullable<T>
float maybeScore = Mock.Float().OrDefault(0.1f); // any T -> default(T)
Object Builders
MockPerson.New() returns an internally consistent record - email and username are derived from the drawn name, the date of birth agrees with Age, and the address parts cohere into a single line. Mock.Datasets.Person() is a friendly alias for the same generator.
MockPerson p = MockPerson.New();
MockPerson[] roster = MockPerson.New(50);
MockOf<T> is a delegate-based fluent builder for any POCO. No reflection, no expression trees - IL2CPP/AOT safe.
User[] users = MockOf<User>
.New(() => new User())
.Set((u, i) => u.Id = i + 1)
.Set(u => u.Name = Mock.Name())
.Set(u => u.Email = Mock.Email())
.UseSeed(42)
.Generate(100);
Image & Themed Text Helpers
*Mock.ImageUrl(width, height) - random picsum.photos URL.
*Mock.PlaceholderImageUrl(width, height, bg, fg, text) - placehold.co URL with optional colours and label.
*Mock.SvgDataUri(width, height, fill, label) - self-contained, offline SVG data URI.
*Mock.HackerPhrase() - tech-flavoured activity-log line, e.g. "Try parsing the SSL sensor, maybe it will reboot the digital bus!". Use Mock.HackerAdjective(), Mock.HackerNoun(), Mock.HackerVerb(), and Mock.HackerIngVerb() when you need individual themed words.
*Mock.Review(minWords, maxWords) - short product-style review string for e-commerce mocks.
Series Data from Code
The MockSeries static class generates patterned datasets.
Full-Featured Generation
using MockMagic;
MockDataPoint[] data = MockSeries.Generate(
pattern: SeriesPattern.TrendingUp,
count: 12,
min: 0f,
max: 100f,
noise: 0.15f,
labelPreset: LabelPreset.MonthsShort
);
// Each point has: data[i].Label, data[i].Value, data[i].SeriesName, etc.
Multi-Series Generation
MockDataPoint[][] multiData = MockSeries.GenerateMultiSeries(
pattern: SeriesPattern.Seasonal,
seriesCount: 3,
pointCount: 12,
min: 0f,
max: 100f,
noise: 0.1f,
labelPreset: LabelPreset.MonthsShort,
seriesNames: new[] { "Revenue", "Costs", "Profit" }
);
// multiData[0] = Revenue series, multiData[1] = Costs series, etc.
Convenience Methods
Short-form methods with sensible defaults:
MockDataPoint[] data = MockSeries.Linear(); // 12 points, 0–100, low noise
MockDataPoint[] data = MockSeries.Sine(); // Sine wave
MockDataPoint[] data = MockSeries.TrendingUp(); // Upward trend
MockDataPoint[] data = MockSeries.TrendingDown(); // Downward trend
MockDataPoint[] data = MockSeries.Seasonal(); // Seasonal pattern
MockDataPoint[] data = MockSeries.BellCurve(); // Normal distribution
MockDataPoint[] data = MockSeries.Random(); // Random values
MockDataPoint[] data = MockSeries.Stepped(); // Staircase
MockDataPoint[] data = MockSeries.Sparse(); // 70% zeros
MockDataPoint[] data = MockSeries.RandomWalk(); // Financial-style random walk
MockDataPoint[] data = MockSeries.Exponential(); // Exponential growth
Raw Values Only
If you only need the float array without labels:
float[] values = MockSeries.GenerateValues(
SeriesPattern.Sine, count: 50, min: -1f, max: 1f, noise: 0f
);
Custom Labels
string[] labels = MockSeries.GenerateLabels(
LabelPreset.MonthsShort, count: 12, startIndex: 0
);
// ["Jan", "Feb", "Mar", ..., "Dec"]
Streaming from Code
For continuous real-time data, use the MockStreaming static convenience class or the MockStream MonoBehaviour singleton directly.
Using MockStreaming (Recommended)
using MockMagic;
using UnityEngine;
public class LiveDashboard : MonoBehaviour
{
private void OnEnable()
{
// Configure the stream
MockStreaming.Configure(
pattern: SeriesPattern.RandomWalk,
min: 0f,
max: 100f,
noise: 0.1f,
pointsPerEmission: 1,
labelPreset: LabelPreset.MonthsShort
);
// Register a listener
MockStreaming.Register(OnDataReceived);
// Start streaming
MockStreaming.Start(interval: 1.0f, rhythm: StreamRhythm.Constant);
}
private void OnDisable()
{
MockStreaming.Unregister(OnDataReceived);
MockStreaming.Stop();
}
private void OnDataReceived(MockDataPoint[] points)
{
foreach (MockDataPoint point in points)
{
Debug.Log($"{point.Label}: {point.Value}");
}
}
}
Using MockStream Directly
MockStream is a singleton MonoBehaviour with full property access:
MockStream stream = MockStream.Instance;
stream.Pattern = SeriesPattern.Sine;
stream.Rhythm = StreamRhythm.Burst;
stream.Interval = 0.5f;
stream.BurstCount = 5;
stream.BurstDelay = 3f;
stream.MinValue = 0f;
stream.MaxValue = 100f;
stream.Noise = 0.1f;
stream.PointsPerEmission = 3;
stream.LabelPreset = LabelPreset.WeekdaysShort;
stream.OnDataEmitted += OnDataReceived;
stream.OnStreamStarted += () => Debug.Log("Stream started");
stream.OnStreamStopped += () => Debug.Log("Stream stopped");
stream.StartStream();
// ... later ...
stream.StopStream();
Single Emission
Fire one emission without starting continuous streaming:
MockStreaming.EmitOnce();
// or
MockStream.Instance.EmitOnce();
Export from Code
The MockExport static class converts data to formatted strings.
Exporting Series Data
using MockMagic;
MockDataPoint[] data = MockSeries.TrendingUp();
string text = MockExport.Export(data, ExportFormat.Text);
string csv = MockExport.Export(data, ExportFormat.Csv);
string json = MockExport.Export(data, ExportFormat.Json);
string code = MockExport.Export(data, ExportFormat.CSharpCode, variableName: "sales");
Exporting Multi-Series Data
MockDataPoint[][] multiData = MockSeries.GenerateMultiSeries(
SeriesPattern.Seasonal, 3, 12, 0f, 100f, 0.1f, LabelPreset.MonthsShort
);
string json = MockExport.Export(multiData, ExportFormat.Json);
Exporting Simple Data
string[] emails = Mock.Emails(20);
string csv = MockExport.Export(emails, ExportFormat.Csv);
Copy to Clipboard
MockExport.CopyToClipboard(data); // MockDataPoint[]
MockExport.CopyToClipboard(multiData); // MockDataPoint[][]
MockExport.CopyToClipboard(emails); // string[]
MockExport.CopyToClipboard("custom string"); // Raw string
Feeding MockMagic Data into Chart Guru
using MockMagic;
using ChartGuru;
using UnityEngine;
public class MockChart : MonoBehaviour
{
private ChartGraphic _chart;
private void Start()
{
// Generate mock data
MockDataPoint[] data = MockSeries.Generate(
SeriesPattern.TrendingUp, 12, 0f, 100f, 0.15f, LabelPreset.MonthsShort
);
// Build a Chart Guru chart
ChartBuilder builder = Chart.Create();
for (int i = 0; i < data.Length; i++)
{
BarMark bar = new BarMark(i, data[i].Value);
bar.CategoryLabel = data[i].Label;
builder.Add(bar);
}
Chart chart = builder
.chartXAxis(x => x.Label("Month"))
.chartYAxis(y => y.Label("Value"))
.Build();
_chart = ChartCanvasHelper.RenderToRectTransform(
chart, GetComponent<RectTransform>(), true, "MockChart"
);
}
}