faketelemetry 0.1.0__tar.gz

faketelemetry-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adam Billekvist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

faketelemetry-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: faketelemetry
+Version: 0.1.0
+Summary: Real-time Fake Telemetry Stream Generator
+Home-page: https://github.com/adkvi/faketelemetry
+Author: Adam Billekvist
+Author-email: adam.billeqvist@example.com
+Project-URL: Documentation, https://github.com/adkvi/faketelemetry#readme
+Project-URL: Source, https://github.com/adkvi/faketelemetry
+Project-URL: Tracker, https://github.com/adkvi/faketelemetry/issues
+Keywords: telemetry,signal,generator,iot,testing,simulation,waveform,python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+[![PyPI version](https://img.shields.io/pypi/v/faketelemetry.svg)](https://pypi.org/project/faketelemetry/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CI](https://github.com/adkvi/faketelemetry/actions/workflows/python-package.yml/badge.svg)](https://github.com/adkvi/faketelemetry/actions)
+
+# FakeTelemetry
+
+**A minimal Python package to generate real-time, timestamped fake telemetry streams for testing, simulation, and development.**
+
+## Features
+- Sine, cosine, square, sawtooth, triangle, pulse, and random noise waveforms
+- Custom user-defined waveform support
+- Adjustable amplitude, frequency, offset, and sample rate
+- Optional Gaussian noise injection
+- Real-time streaming of (datetime, value) tuples
+- Multi-channel (parallel) telemetry generation
+- Well-tested and extensible
+
+## Example Usage
+
+```python
+from faketelemetry import TelemetryGenerator, WaveformType, NoiseInjector, MultiChannelTelemetryGenerator
+
+# Single channel with noise (sine wave)
+noise = NoiseInjector(noise_level=0.2)
+gen = TelemetryGenerator(
+    waveform=WaveformType.SINE,
+    frequency=1.0,
+    amplitude=1.0,
+    offset=0.0,
+    noise_injector=noise
+)
+for timestamp, value in gen.stream(sampling_rate=2.0, duration=3):
+    print(timestamp, value)
+
+# Multi-channel example (sine and cosine)
+ch1 = TelemetryGenerator(WaveformType.SINE, frequency=1.0)
+ch2 = TelemetryGenerator(WaveformType.COSINE, frequency=0.5)
+multi = MultiChannelTelemetryGenerator([ch1, ch2])
+for sample in multi.stream(sampling_rate=2.0, duration=3):
+    print({k: (v[0], v[1]) for k, v in sample.items()})
+
+# Triangle and pulse waveforms
+tri = TelemetryGenerator(WaveformType.TRIANGLE, frequency=1.0)
+pulse = TelemetryGenerator(WaveformType.PULSE, frequency=1.0)
+print('Triangle:', next(tri.stream(1)))
+print('Pulse:', next(pulse.stream(1)))
+
+# Custom waveform (e.g., constant 42)
+def custom_func(t):
+    return 42.0
+gen_custom = TelemetryGenerator(WaveformType.CUSTOM, custom_func=custom_func)
+print('Custom:', next(gen_custom.stream(1)))
+```
+
+## Installation
+
+Clone this repo and install locally:
+
+```sh
+pip install .
+```
+
+Or install in editable/development mode:
+
+```sh
+pip install -e .
+```
+
+## Testing
+
+Run all tests:
+
+```sh
+python -m unittest discover -s tests
+```
+
+## License
+MIT

faketelemetry-0.1.0/README.md

@@ -0,0 +1,78 @@
+[![PyPI version](https://img.shields.io/pypi/v/faketelemetry.svg)](https://pypi.org/project/faketelemetry/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CI](https://github.com/adkvi/faketelemetry/actions/workflows/python-package.yml/badge.svg)](https://github.com/adkvi/faketelemetry/actions)
+
+# FakeTelemetry
+
+**A minimal Python package to generate real-time, timestamped fake telemetry streams for testing, simulation, and development.**
+
+## Features
+- Sine, cosine, square, sawtooth, triangle, pulse, and random noise waveforms
+- Custom user-defined waveform support
+- Adjustable amplitude, frequency, offset, and sample rate
+- Optional Gaussian noise injection
+- Real-time streaming of (datetime, value) tuples
+- Multi-channel (parallel) telemetry generation
+- Well-tested and extensible
+
+## Example Usage
+
+```python
+from faketelemetry import TelemetryGenerator, WaveformType, NoiseInjector, MultiChannelTelemetryGenerator
+
+# Single channel with noise (sine wave)
+noise = NoiseInjector(noise_level=0.2)
+gen = TelemetryGenerator(
+    waveform=WaveformType.SINE,
+    frequency=1.0,
+    amplitude=1.0,
+    offset=0.0,
+    noise_injector=noise
+)
+for timestamp, value in gen.stream(sampling_rate=2.0, duration=3):
+    print(timestamp, value)
+
+# Multi-channel example (sine and cosine)
+ch1 = TelemetryGenerator(WaveformType.SINE, frequency=1.0)
+ch2 = TelemetryGenerator(WaveformType.COSINE, frequency=0.5)
+multi = MultiChannelTelemetryGenerator([ch1, ch2])
+for sample in multi.stream(sampling_rate=2.0, duration=3):
+    print({k: (v[0], v[1]) for k, v in sample.items()})
+
+# Triangle and pulse waveforms
+tri = TelemetryGenerator(WaveformType.TRIANGLE, frequency=1.0)
+pulse = TelemetryGenerator(WaveformType.PULSE, frequency=1.0)
+print('Triangle:', next(tri.stream(1)))
+print('Pulse:', next(pulse.stream(1)))
+
+# Custom waveform (e.g., constant 42)
+def custom_func(t):
+    return 42.0
+gen_custom = TelemetryGenerator(WaveformType.CUSTOM, custom_func=custom_func)
+print('Custom:', next(gen_custom.stream(1)))
+```
+
+## Installation
+
+Clone this repo and install locally:
+
+```sh
+pip install .
+```
+
+Or install in editable/development mode:
+
+```sh
+pip install -e .
+```
+
+## Testing
+
+Run all tests:
+
+```sh
+python -m unittest discover -s tests
+```
+
+## License
+MIT

faketelemetry-0.1.0/faketelemetry/__init__.py

@@ -0,0 +1,6 @@
+from .telemetry_generator import TelemetryGenerator
+from .multi_channel import MultiChannelTelemetryGenerator
+from .noise_injector import NoiseInjector
+from .enums import WaveformType
+
+__version__ = "0.1.0"

faketelemetry-0.1.0/faketelemetry/enums.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class WaveformType(Enum):
+    """
+    Enumeration of supported waveform types for telemetry generation.
+    """
+
+    SINE = "sine"
+    COSINE = "cosine"
+    SQUARE = "square"
+    SAWTOOTH = "sawtooth"
+    TRIANGLE = "triangle"
+    PULSE = "pulse"
+    RANDOM_NOISE = "random_noise"
+    CUSTOM = "custom"

faketelemetry-0.1.0/faketelemetry/multi_channel.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+import time
+from typing import Optional
+from .telemetry_generator import TelemetryGenerator
+
+
+class MultiChannelTelemetryGenerator:
+    """
+    Generate multiple telemetry streams (channels) in parallel.
+    """
+
+    def __init__(self, generators: list[TelemetryGenerator]):
+        """
+        :param generators: List of TelemetryGenerator instances (one per channel)
+        """
+        self.generators = generators
+
+    def stream(self, sampling_rate: float, duration: Optional[float] = None):
+        """
+        Yield a dict of {channel_index: (datetime, value)} for each sample.
+        """
+        interval = 1.0 / sampling_rate
+        start_time = time.time()
+        elapsed = 0.0
+        while duration is None or elapsed < duration:
+            now = time.time() - start_time
+            result = {}
+            for idx, gen in enumerate(self.generators):
+                value = gen.generate_point(now)
+                result[idx] = (datetime.now(), value)
+            yield result
+            time.sleep(interval)
+            elapsed = time.time() - start_time

faketelemetry-0.1.0/faketelemetry/noise_injector.py

@@ -0,0 +1,21 @@
+import random
+
+
+class NoiseInjector:
+    """
+    Injects Gaussian noise into a signal value.
+    """
+
+    def __init__(self, noise_level: float = 0.0):
+        """
+        :param noise_level: Standard deviation of the Gaussian noise.
+        """
+        self.noise_level = noise_level
+
+    def add_noise(self, value: float) -> float:
+        """
+        Add Gaussian noise to the input value.
+        """
+        if self.noise_level > 0:
+            return value + random.gauss(0, self.noise_level)
+        return value

faketelemetry-0.1.0/faketelemetry/telemetry_generator.py

@@ -0,0 +1,119 @@
+import math
+import time
+import random
+from datetime import datetime
+from typing import Iterator, Tuple, Optional, Callable
+from .enums import WaveformType
+from .noise_injector import NoiseInjector
+
+
+class TelemetryGenerator:
+    """
+    Generates real-time telemetry data based on mathematical waveforms.
+    """
+
+    def __init__(
+        self,
+        waveform: WaveformType,
+        frequency: float = 1.0,
+        amplitude: float = 1.0,
+        offset: float = 0.0,
+        noise_injector: Optional[NoiseInjector] = None,
+        custom_func: Optional[Callable[[float], float]] = None,
+    ):
+        """
+        Initialize the telemetry generator.
+        :param waveform: Type of signal to generate
+        :param frequency: Frequency in Hz (must be >= 0)
+        :param amplitude: Peak amplitude (must be >= 0)
+        :param offset: Base offset (vertical shift)
+        :param noise_injector: Optional NoiseInjector
+        :param custom_func: Optional function for custom waveform, signature: (t: float) -> float
+        """
+        if frequency < 0:
+            raise ValueError("Frequency must be non-negative.")
+        if amplitude < 0:
+            raise ValueError("Amplitude must be non-negative.")
+        if waveform == WaveformType.CUSTOM and not callable(custom_func):
+            raise ValueError(
+                "A callable custom_func must be provided for CUSTOM waveform."
+            )
+        self.waveform = waveform
+        self.frequency = frequency
+        self.amplitude = amplitude
+        self.offset = offset
+        self.noise_injector = noise_injector
+        self.custom_func = custom_func
+
+    def generate_point(self, t: float) -> float:
+        """
+        Generate a signal value at time t (seconds).
+        """
+        if t < 0:
+            raise ValueError("Time t must be non-negative.")
+        if self.waveform == WaveformType.SINE:
+            value = (
+                self.amplitude * math.sin(2 * math.pi * self.frequency * t)
+                + self.offset
+            )
+        elif self.waveform == WaveformType.COSINE:
+            value = (
+                self.amplitude * math.cos(2 * math.pi * self.frequency * t)
+                + self.offset
+            )
+        elif self.waveform == WaveformType.SQUARE:
+            value = (
+                self.amplitude
+                * (1 if math.sin(2 * math.pi * self.frequency * t) >= 0 else -1)
+                + self.offset
+            )
+        elif self.waveform == WaveformType.SAWTOOTH:
+            value = (
+                self.amplitude
+                * (2 * (t * self.frequency - math.floor(0.5 + t * self.frequency)))
+                + self.offset
+            )
+        elif self.waveform == WaveformType.TRIANGLE:
+            value = (
+                self.amplitude
+                * (
+                    2
+                    * abs(
+                        2 * (t * self.frequency - math.floor(t * self.frequency + 0.5))
+                    )
+                    - 1
+                )
+                + self.offset
+            )
+        elif self.waveform == WaveformType.PULSE:
+            value = (
+                self.amplitude * (1 if (t * self.frequency) % 1 < 0.1 else 0)
+                + self.offset
+            )
+        elif self.waveform == WaveformType.RANDOM_NOISE:
+            value = self.amplitude * random.gauss(0, 1) + self.offset
+        elif self.waveform == WaveformType.CUSTOM:
+            if self.custom_func is None:
+                raise ValueError("Custom waveform requires a custom_func argument.")
+            value = self.custom_func(t)
+        else:
+            raise ValueError(f"Unsupported waveform: {self.waveform}")
+        if self.noise_injector:
+            value = self.noise_injector.add_noise(value)
+        return value
+
+    def stream(
+        self, sampling_rate: float, duration: Optional[float] = None
+    ) -> Iterator[Tuple[datetime, float]]:
+        """
+        Stream (datetime, value) tuples in real-time at the given sampling rate.
+        """
+        interval = 1.0 / sampling_rate
+        start_time = time.time()
+        elapsed = 0.0
+        while duration is None or elapsed < duration:
+            now = time.time() - start_time
+            value = self.generate_point(now)
+            yield (datetime.now(), value)
+            time.sleep(interval)
+            elapsed = time.time() - start_time

faketelemetry-0.1.0/faketelemetry.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: faketelemetry
+Version: 0.1.0
+Summary: Real-time Fake Telemetry Stream Generator
+Home-page: https://github.com/adkvi/faketelemetry
+Author: Adam Billekvist
+Author-email: adam.billeqvist@example.com
+Project-URL: Documentation, https://github.com/adkvi/faketelemetry#readme
+Project-URL: Source, https://github.com/adkvi/faketelemetry
+Project-URL: Tracker, https://github.com/adkvi/faketelemetry/issues
+Keywords: telemetry,signal,generator,iot,testing,simulation,waveform,python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+[![PyPI version](https://img.shields.io/pypi/v/faketelemetry.svg)](https://pypi.org/project/faketelemetry/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CI](https://github.com/adkvi/faketelemetry/actions/workflows/python-package.yml/badge.svg)](https://github.com/adkvi/faketelemetry/actions)
+
+# FakeTelemetry
+
+**A minimal Python package to generate real-time, timestamped fake telemetry streams for testing, simulation, and development.**
+
+## Features
+- Sine, cosine, square, sawtooth, triangle, pulse, and random noise waveforms
+- Custom user-defined waveform support
+- Adjustable amplitude, frequency, offset, and sample rate
+- Optional Gaussian noise injection
+- Real-time streaming of (datetime, value) tuples
+- Multi-channel (parallel) telemetry generation
+- Well-tested and extensible
+
+## Example Usage
+
+```python
+from faketelemetry import TelemetryGenerator, WaveformType, NoiseInjector, MultiChannelTelemetryGenerator
+
+# Single channel with noise (sine wave)
+noise = NoiseInjector(noise_level=0.2)
+gen = TelemetryGenerator(
+    waveform=WaveformType.SINE,
+    frequency=1.0,
+    amplitude=1.0,
+    offset=0.0,
+    noise_injector=noise
+)
+for timestamp, value in gen.stream(sampling_rate=2.0, duration=3):
+    print(timestamp, value)
+
+# Multi-channel example (sine and cosine)
+ch1 = TelemetryGenerator(WaveformType.SINE, frequency=1.0)
+ch2 = TelemetryGenerator(WaveformType.COSINE, frequency=0.5)
+multi = MultiChannelTelemetryGenerator([ch1, ch2])
+for sample in multi.stream(sampling_rate=2.0, duration=3):
+    print({k: (v[0], v[1]) for k, v in sample.items()})
+
+# Triangle and pulse waveforms
+tri = TelemetryGenerator(WaveformType.TRIANGLE, frequency=1.0)
+pulse = TelemetryGenerator(WaveformType.PULSE, frequency=1.0)
+print('Triangle:', next(tri.stream(1)))
+print('Pulse:', next(pulse.stream(1)))
+
+# Custom waveform (e.g., constant 42)
+def custom_func(t):
+    return 42.0
+gen_custom = TelemetryGenerator(WaveformType.CUSTOM, custom_func=custom_func)
+print('Custom:', next(gen_custom.stream(1)))
+```
+
+## Installation
+
+Clone this repo and install locally:
+
+```sh
+pip install .
+```
+
+Or install in editable/development mode:
+
+```sh
+pip install -e .
+```
+
+## Testing
+
+Run all tests:
+
+```sh
+python -m unittest discover -s tests
+```
+
+## License
+MIT

faketelemetry-0.1.0/faketelemetry.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+faketelemetry/__init__.py
+faketelemetry/enums.py
+faketelemetry/multi_channel.py
+faketelemetry/noise_injector.py
+faketelemetry/telemetry_generator.py
+faketelemetry.egg-info/PKG-INFO
+faketelemetry.egg-info/SOURCES.txt
+faketelemetry.egg-info/dependency_links.txt
+faketelemetry.egg-info/top_level.txt
+tests/test_generator.py
+tests/test_noise.py

faketelemetry-0.1.0/faketelemetry.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

faketelemetry-0.1.0/faketelemetry.egg-info/top_level.txt

@@ -0,0 +1 @@
+faketelemetry

faketelemetry-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"

faketelemetry-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

faketelemetry-0.1.0/setup.py

@@ -0,0 +1,36 @@
+from setuptools import setup, find_packages
+import pathlib
+
+here = pathlib.Path(__file__).parent.resolve()
+long_description = (here / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="faketelemetry",
+    version="0.1.0",
+    description="Real-time Fake Telemetry Stream Generator",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Adam Billekvist",
+    author_email="adam.billeqvist@example.com",
+    url="https://github.com/adkvi/faketelemetry",
+    project_urls={
+        "Documentation": "https://github.com/adkvi/faketelemetry#readme",
+        "Source": "https://github.com/adkvi/faketelemetry",
+        "Tracker": "https://github.com/adkvi/faketelemetry/issues",
+    },
+    keywords=[
+        "telemetry", "signal", "generator", "iot", "testing", "simulation", "waveform", "python"
+    ],
+    packages=find_packages(),
+    install_requires=[],
+    python_requires=">=3.7",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Scientific/Engineering :: Information Analysis",
+        "Topic :: Software Development :: Testing",
+    ],
+)

faketelemetry-0.1.0/tests/test_generator.py

@@ -0,0 +1,101 @@
+import unittest
+from datetime import datetime
+from faketelemetry import (
+    TelemetryGenerator,
+    WaveformType,
+    MultiChannelTelemetryGenerator,
+)
+
+
+class TestTelemetryGenerator(unittest.TestCase):
+    def test_sine_wave(self):
+        gen = TelemetryGenerator(
+            WaveformType.SINE, frequency=1.0, amplitude=2.0, offset=1.0
+        )
+        value = gen.generate_point(0)
+        self.assertAlmostEqual(value, 1.0)
+        value = gen.generate_point(0.25)
+        self.assertAlmostEqual(value, 3.0, places=1)
+
+    def test_cosine_wave(self):
+        gen = TelemetryGenerator(
+            WaveformType.COSINE, frequency=1.0, amplitude=1.0, offset=0.0
+        )
+        value = gen.generate_point(0)
+        self.assertAlmostEqual(value, 1.0)
+
+    def test_square_wave(self):
+        gen = TelemetryGenerator(
+            WaveformType.SQUARE, frequency=1.0, amplitude=1.0, offset=0.0
+        )
+        self.assertIn(gen.generate_point(0), [1.0, -1.0])
+
+    def test_sawtooth_wave(self):
+        gen = TelemetryGenerator(
+            WaveformType.SAWTOOTH, frequency=1.0, amplitude=1.0, offset=0.0
+        )
+        value = gen.generate_point(0)
+        self.assertAlmostEqual(value, 0.0)
+
+    def test_multichannel_stream(self):
+        gen1 = TelemetryGenerator(WaveformType.SINE, frequency=1.0)
+        gen2 = TelemetryGenerator(WaveformType.COSINE, frequency=2.0)
+        multi = MultiChannelTelemetryGenerator([gen1, gen2])
+        stream = multi.stream(sampling_rate=2.0, duration=1)
+        results = list(stream)
+        self.assertTrue(len(results) > 0)
+        for sample in results:
+            self.assertEqual(len(sample), 2)
+            for v in sample.values():
+                self.assertIsInstance(v[0], datetime)
+                self.assertIsInstance(v[1], float)
+
+    def test_triangle_wave(self):
+        gen = TelemetryGenerator(
+            WaveformType.TRIANGLE, frequency=1.0, amplitude=1.0, offset=0.0
+        )
+        self.assertAlmostEqual(gen.generate_point(0), -1.0, places=1)
+        self.assertAlmostEqual(gen.generate_point(0.25), 0.0, places=1)
+        self.assertAlmostEqual(gen.generate_point(0.5), 1.0, places=1)
+        self.assertAlmostEqual(gen.generate_point(0.75), 0.0, places=1)
+
+    def test_pulse_wave(self):
+        gen = TelemetryGenerator(
+            WaveformType.PULSE, frequency=1.0, amplitude=1.0, offset=0.0
+        )
+        self.assertEqual(gen.generate_point(0), 1.0)
+        self.assertEqual(gen.generate_point(0.11), 0.0)
+        self.assertEqual(gen.generate_point(1.0), 1.0)
+
+    def test_custom_wave(self):
+        def custom_func(t):
+            return 42.0
+
+        gen = TelemetryGenerator(WaveformType.CUSTOM, custom_func=custom_func)
+        self.assertEqual(gen.generate_point(0), 42.0)
+        self.assertEqual(gen.generate_point(1), 42.0)
+
+    def test_invalid_frequency(self):
+        with self.assertRaises(ValueError) as cm:
+            TelemetryGenerator(WaveformType.SINE, frequency=-1)
+        self.assertIn("Frequency must be non-negative", str(cm.exception))
+
+    def test_invalid_amplitude(self):
+        with self.assertRaises(ValueError) as cm:
+            TelemetryGenerator(WaveformType.SINE, amplitude=-1)
+        self.assertIn("Amplitude must be non-negative", str(cm.exception))
+
+    def test_invalid_custom_func(self):
+        with self.assertRaises(ValueError) as cm:
+            TelemetryGenerator(WaveformType.CUSTOM, custom_func=None)
+        self.assertIn("callable custom_func", str(cm.exception))
+
+    def test_negative_time(self):
+        gen = TelemetryGenerator(WaveformType.SINE)
+        with self.assertRaises(ValueError) as cm:
+            gen.generate_point(-1)
+        self.assertIn("Time t must be non-negative", str(cm.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()

faketelemetry-0.1.0/tests/test_noise.py

@@ -0,0 +1,17 @@
+import unittest
+from faketelemetry.noise_injector import NoiseInjector
+
+
+class TestNoiseInjector(unittest.TestCase):
+    def test_no_noise(self):
+        ni = NoiseInjector(noise_level=0.0)
+        self.assertEqual(ni.add_noise(5.0), 5.0)
+
+    def test_with_noise(self):
+        ni = NoiseInjector(noise_level=1.0)
+        values = [ni.add_noise(5.0) for _ in range(100)]
+        self.assertTrue(any(abs(v - 5.0) > 0.1 for v in values))
+
+
+if __name__ == "__main__":
+    unittest.main()