Share lossless voice prefixes across companion announcements

This commit is contained in:
mikecarper committed 2026-10-03 19:11:15 -07:00
1 parent 91a9190a71
commit 22360f4392
18 files changed
+2284 -2018

No files matched your search

+66
View File
@@ -0,0 +1,66 @@
#include <cassert>
#include <cstdio>
#include <cstring>
#include <initializer_list>
#define PIN_BUZZER 25
#define MESH_BUTTON_AUDIO_HIL 1
#if defined(MESH_GPS_VOICE_G726_BITRATE)
#include <helpers/ui/G726VoiceData.h>
#else
#include <helpers/ui/ButtonVoiceData.h>
#include <helpers/ui/GpsVoiceData.h>
#endif
#include <helpers/ui/nrf52/GpsVoicePlayer.h>
uint32_t now_ms=0;
int main() {
using namespace mesh::audio;
const VoiceClip clips[]={readyClip,notificationClearedClip,advertQueuedClip,
advertFailedClip,soundOnClip,soundOffClip,actionFailedClip,usbSetupClip,
shuttingDownClip,restartingClip,gpsOnClip,gpsOffClip,
#ifdef HAS_DRV2605
alertsSoundVibrationClip,alertsSoundOnlyClip,alertsVibrationOnlyClip,alertsSilentClip,
#endif
};
for (auto clip:clips) {
#ifdef PWM_OUTPUT
GpsVoicePlayer player;
assert(player.setGain(2));
assert(player.start(clip));
uint16_t first[2][128];
for(unsigned i=0;i<2;++i)
std::memcpy(first[i],reinterpret_cast<const void*>(registers.SEQ[i].PTR),sizeof(first[i]));
unsigned sequence=0,events=0;
while (player.playing()) {
assert(++events<1000);
const auto data=reinterpret_cast<const uint16_t*>(registers.SEQ[sequence].PTR);
assert(std::fwrite(data,sizeof(*data),registers.SEQ[sequence].CNT,stdout)==registers.SEQ[sequence].CNT);
registers.EVENTS_SEQEND[sequence]=1;player.interrupt();sequence^=1;
}
assert(player.played()==clip.samples);
assert(player.completed()==1&&player.cancelled()==0);
player.service();assert(!player.active()&&!HwPWM3.owned&&!irq_enabled);
// Cancel before and after the GPS prefix seam, then restart. A tail must
// never inherit another announcement's adaptive/interpolation state.
for(unsigned fraction:{1u,3u}) {
assert(player.start(clip));unsigned seq=0;
while(player.playing()&&player.played()<clip.samples*fraction/4) {
registers.EVENTS_SEQEND[seq]=1;player.interrupt();seq^=1;
}
assert(player.playing());player.stop();
assert(!player.active()&&!HwPWM3.owned&&!irq_enabled);
assert(player.start(clip));
for(unsigned i=0;i<2;++i)
assert(std::memcmp(first[i],reinterpret_cast<const void*>(registers.SEQ[i].PTR),sizeof(first[i]))==0);
player.stop();
}
assert(player.started()==5&&player.completed()==1&&player.cancelled()==4);
#else
VoiceDecoder decoder;decoder.begin(clip);
for(uint32_t sample=0;sample<clip.samples;++sample) {
assert(!decoder.done());const int16_t value=decoder.next();
assert(std::fwrite(&value,sizeof(value),1,stdout)==1);
}
assert(decoder.done()&&decoder.position()==clip.samples&&decoder.next()==0);
#endif
}
}
+2 -1
View File
@@ -59,8 +59,9 @@ int main(){
for(const auto& entry:mappings){
auto actual=buttonVoiceClip(entry.prompt);
assert(actual.data==entry.clip.data&&actual.bytes==entry.clip.bytes);
assert(actual.prefix==entry.clip.prefix&&actual.prefix_bytes==entry.clip.prefix_bytes);
assert(actual.samples==entry.clip.samples&&actual.sample_rate==entry.clip.sample_rate);
assert(actual.data&&actual.bytes==(actual.samples+1)/2);
assert(actual.valid()&&actual.bytes+actual.prefix_bytes==(actual.samples+1)/2);
assert(actual.sample_rate==8000||actual.sample_rate==16000);
VoiceDecoder decoder;decoder.begin(actual);
unsigned count=0,nonzero=0;
+61 -13
View File
@@ -1,6 +1,7 @@
"""Validate the fixed prerecorded catalog without speech synthesis or hardware."""
from pathlib import Path
import hashlib
import importlib.util
import re
import shutil
import struct
@@ -64,22 +65,69 @@ def write_wav(path, samples, *, rate=8000, channels=1, width=2):
wav.writeframes(payload)
def parse_header(source):
arrays = {
def select_vibration(source, enabled=True):
"""Select the generated catalog's HAS_DRV2605 branches for asset tests."""
lines = []
stack = [True]
for line in source.splitlines():
if line == '#ifdef HAS_DRV2605':
stack.append(stack[-1] and enabled)
elif line == '#else' and len(stack) > 1:
stack[-1] = stack[-2] and not stack[-1]
elif line == '#endif // HAS_DRV2605':
stack.pop()
elif stack[-1]:
lines.append(line)
assert len(stack) == 1
return '\n'.join(lines)
def parse_header(source, has_drv2605=True):
source = select_vibration(source, has_drv2605)
spans = {
name: bytes(int(value, 16) for value in re.findall(r"0x([0-9a-fA-F]{2})", body))
for name, body in re.findall(
r"static const uint8_t (\w+)Data\[\] = \{(.*?)\};", source, re.S)
}
clips = {
name: (data, size, int(samples), int(rate))
for name, data, size, samples, rate in re.findall(
arrays, clips = {}, {}
for name, data, size, samples, rate, prefix, prefix_size in re.findall(
r"static constexpr VoiceClip (\w+)Clip = \{\s*"
r"(\w+)Data, sizeof\((\w+)Data\), (\d+), (\d+)\s*\};", source)
}
r"(\w+)Data, sizeof\((\w+)Data\), (\d+), (\d+)"
r"(?:, (\w+)Data, sizeof\((\w+)Data\))?\s*\};", source):
assert data == size and prefix == prefix_size
clips[name] = (data, size, int(samples), int(rate))
arrays[name] = (spans[prefix] if prefix else b'') + spans[data]
return arrays, clips
class EncoderTests(unittest.TestCase):
def test_profitable_prefix_groups_regenerate_exact_phrases_for_both_board_policies(self):
with tempfile.TemporaryDirectory() as temporary:
directory = Path(temporary)
samples = self.fixtures(directory)
common = [((i*997)%18001)-9000 for i in range(257)]
for name, tail in (('advertQueued',[1000,-1000]), ('advertFailed',[-3000,3000]),
('soundOff',[2000,-2000]), ('alertsSoundOnly',[-4000,4000])):
samples[name] = common+tail*80
write_wav(directory/(name+'.wav'), samples[name])
source = directory/'shared.h'
self.assertEqual(self.generate(directory,source).returncode,0)
header = source.read_text()
self.assertIn('advertPrefixData',header)
self.assertIn('soundPrefixData',header)
# Compare to the original independently encoded fixture bytes.
spec = importlib.util.spec_from_file_location(
'fixture_gps_encoder',ROOT/'scripts/generate_gps_voice.py')
encoder = importlib.util.module_from_spec(spec)
spec.loader.exec_module(encoder)
for vibration in (False,True):
arrays, clips = parse_header(header,vibration)
names = CATALOG if vibration else CATALOG[:10]
for name,_ in names:
self.assertEqual(arrays[name],encoder.encode(samples[name]))
self.assertEqual(clips[name],(name,name,len(samples[name]),8000))
self.assertEqual('soundPrefixData' in select_vibration(header,vibration),vibration)
def fixtures(self, directory):
samples = {}
for index, (name, _) in enumerate(CATALOG):
@@ -175,12 +223,12 @@ class EncoderTests(unittest.TestCase):
self.assertEqual(clips[name], (name, name, samples, 8000))
def assert_x1_only_recordings_are_guarded(self, source):
start = source.index('#ifdef HAS_DRV2605')
end = source.index('#endif', start)
self.assertLess(source.index('restartingClip'), start)
for name, _ in CATALOG[10:]:
self.assertLess(start, source.index(name+'Data'))
self.assertLess(source.index(name+'Clip'), end)
arrays, clips = parse_header(source, has_drv2605=False)
self.assertEqual(tuple(arrays), tuple(name for name, _ in CATALOG[:10]))
self.assertEqual(tuple(clips), tuple(arrays))
# The optional shared Sound prefix must not add storage on boards
# which have no sound-only alert-mode announcement.
self.assertNotIn('soundPrefixData', select_vibration(source, False))
def test_changed_source_wav_replaces_only_its_matching_clip(self):
with tempfile.TemporaryDirectory() as temporary:
+34 -1
View File
@@ -17,7 +17,8 @@ ROOT = Path(__file__).resolve().parents[1]
CC = shutil.which('gcc')
CXX = shutil.which('g++')
DECODER = ROOT / 'src/helpers/ui/g726/g726_decoder.c'
SANITIZERS = (['-fsanitize=address,undefined', '-fno-omit-frame-pointer']
SANITIZERS = (['-fsanitize=address,undefined', '-fno-sanitize-recover=all',
'-fno-omit-frame-pointer', '-fno-pie', '-no-pie']
if os.environ.get('MESH_G726_TEST_SANITIZERS') == '1' else [])
# FFmpeg 7.1 g726 encoder/decoder, 8 kHz mono, continuous MSB-first packing.
@@ -230,6 +231,38 @@ class Tests(unittest.TestCase):
for bitrate in VECTORS:
with self.subTest(bitrate=bitrate):self.build(self.fixture(PLAYER_MAIN,bitrate),bitrate)
def test_segmented_stream_preserves_cross_byte_codes_adaptive_state_and_bounds(self):
source = DECODE_MAIN.split('int main(){', 1)[1].split(' assert(full.valid()', 1)[0]
source = 'int main(){' + source + r'''
for(size_t split=0;split<sizeof(data);++split){
VoiceClip clip{data+split,sizeof(data)-split,count,8000,codec,data,split};
assert(clip.valid());VoiceDecoder decoder;decoder.begin(clip);
for(unsigned i=0;i<count;++i){assert(!decoder.done());assert(decoder.next()==expected[i]);}
assert(decoder.done()&&decoder.position()==count);
for(size_t tail=0;tail<sizeof(data)-split;++tail){
std::vector<uint8_t> prefix(data,data+split),suffix(data+split,data+split+tail);
// A non-null placeholder is legal when the suffix's declared length is
// zero. ASan bounds the actual prefix/tail allocation independently.
VoiceClip short_clip{tail?suffix.data():data,tail,count,8000,codec,
split?prefix.data():nullptr,split};
assert(!short_clip.valid());decoder.begin(short_clip);
const unsigned available=static_cast<unsigned>((split+tail)*8/bits);
for(unsigned i=0;i<available;++i){assert(!decoder.done());assert(decoder.next()==expected[i]);}
assert(decoder.done()&&decoder.position()==available&&decoder.next()==0);
}
}
VoiceClip missing_prefix{data,sizeof(data),count,8000,codec,nullptr,1};
assert(!missing_prefix.valid());VoiceDecoder decoder;decoder.begin(missing_prefix);
assert(decoder.done()&&decoder.next()==0);
VoiceClip huge{data,std::numeric_limits<size_t>::max(),
std::numeric_limits<uint32_t>::max(),8000,codec,data,1};
assert(huge.valid()&&huge.hasBytes(std::numeric_limits<size_t>::max()));
GpsVoicePlayer player;assert(!player.start(missing_prefix)&&!player.active());
}
'''
for bitrate in VECTORS:
with self.subTest(bitrate=bitrate):self.build(self.fixture(source,bitrate),bitrate)
def test_invalid_bitrates_or_missing_laboratory_gate_cannot_compile(self):
for flags,error in (
('#define MESH_GPS_VOICE_G726_BITRATE 16\n','opt-in MESH_BUTTON_AUDIO_HIL'),
+19 -20
View File
@@ -12,7 +12,7 @@ from types import SimpleNamespace
import unittest
from unittest import mock
from test_button_voice_generator import CATALOG, ZIRA_RECORDINGS
from test_button_voice_generator import CATALOG, ZIRA_RECORDINGS, select_vibration
from test_gps_voice_generator import ZIRA_GPS_RECORDINGS
ROOT = Path(__file__).resolve().parents[1]
@@ -114,8 +114,9 @@ class CatalogTests(unittest.TestCase):
for name in names:
count=len(source_samples[name])
self.assertIn(f'{name}Data, sizeof({name}Data), {count}, 8000, VoiceCodec::G726{bitrate}',body)
self.assertEqual(body.count('#ifdef HAS_DRV2605'),4)
self.assertEqual(body.count('#endif // HAS_DRV2605'),4)
plain = select_vibration(body, False)
for name in names:
self.assertEqual(f'{name}Clip' in plain, not name.startswith('alerts'))
def test_invalid_source_lengths_preserve_existing_experimental_header(self):
for count in (0,32001):
@@ -143,30 +144,28 @@ class CatalogTests(unittest.TestCase):
with self.subTest(bitrate=bitrate):
body=source.split(f'#if MESH_GPS_VOICE_G726_BITRATE == {bitrate}\n',1)[1]
body=body.split(f'#endif // {bitrate} kbps',1)[0]
arrays={name:bytes(int(value,16) for value in re.findall(r'0x([0-9a-fA-F]{2})',data))
for name,data in re.findall(r'static const uint8_t (\w+)Data\[\] = \{(.*?)\};',body,re.S)}
clips={name:(data,size,int(count),int(rate),int(codec))
for name,data,size,count,rate,codec in re.findall(
selected = select_vibration(body)
spans={name:bytes(int(value,16) for value in re.findall(r'0x([0-9a-fA-F]{2})',data))
for name,data in re.findall(r'static const uint8_t (\w+)Data\[\] = \{(.*?)\};',selected,re.S)}
arrays, clips = {}, {}
for name,data,size,count,rate,codec,prefix,prefix_size in re.findall(
r'static constexpr VoiceClip (\w+)Clip = \{\s*'
r'(\w+)Data, sizeof\((\w+)Data\), (\d+), (\d+), VoiceCodec::G726(\d+)\s*\};',body)}
r'(\w+)Data, sizeof\((\w+)Data\), (\d+), (\d+), VoiceCodec::G726(\d+)'
r'(?:, (\w+)Data, sizeof\((\w+)Data\))?\s*\};',selected):
self.assertEqual(data,size)
self.assertEqual(prefix,prefix_size)
arrays[name]=(spans[prefix] if prefix else b'')+spans[data]
clips[name]=(data,size,int(count),int(rate),int(codec))
self.assertEqual(tuple(arrays),names)
self.assertEqual(tuple(clips),names)
for name in names:
self.assertEqual(clips[name],(name,name,samples[name],8000,bitrate))
self.assertEqual(len(arrays[name]),(samples[name]*(bitrate//8)+7)//8)
self.assertEqual(hashlib.sha256(arrays[name]).hexdigest(),GOLDENS[name][index],name)
# Each optional mode must be inside a HAS_DRV2605 guard; the
# common twelve clips must remain outside those guards.
guarded=False
for line in body.splitlines():
if line=='#ifdef HAS_DRV2605':
self.assertFalse(guarded);guarded=True
elif line=='#endif // HAS_DRV2605':
self.assertTrue(guarded);guarded=False
else:
match=re.match(r'static const uint8_t (\w+)Data',line)
if match:self.assertEqual(guarded,match[1].startswith('alerts'),match[1])
self.assertFalse(guarded)
plain=select_vibration(body,False)
self.assertNotIn('soundPrefixData',plain)
for name in names:
self.assertEqual(f'{name}Clip' in plain,not name.startswith('alerts'))
def test_cli_refuses_production_filenames_and_invalid_voice_without_touching_existing_files(self):
with tempfile.TemporaryDirectory() as temporary:
+1 -1
View File
@@ -451,7 +451,7 @@ class Tests(unittest.TestCase):
self.build(PLAYER_PDM)
source=PLAYER_PDM.replace('gpsOnClip', 'clip')
source=source.replace('GpsVoicePlayer player;',
'GpsVoicePlayer player; VoiceClip clip{gpsOnClip.data,gpsOnClip.bytes,gpsOnClip.samples,16000};')
'GpsVoicePlayer player; auto clip=gpsOnClip; clip.sample_rate=16000;')
source=source.replace('interpolator.begin();','interpolator.begin(clip.sample_rate);')
source=source.replace('clip.samples*8','clip.samples*4')
self.build(source)
+32
View File
@@ -7,6 +7,7 @@ import sys
import tempfile
import unittest
from test_button_voice_generator import parse_header, write_wav
import importlib.util
ROOT = Path(__file__).resolve().parents[1]
POWERSHELL = shutil.which("pwsh") or shutil.which("powershell")
@@ -33,6 +34,37 @@ ZIRA_GPS_RECORDINGS = {
class AssetTests(unittest.TestCase):
def test_generator_shares_only_profitable_exact_encoded_prefixes(self):
spec = importlib.util.spec_from_file_location('gps_encoder', ROOT/'scripts/generate_gps_voice.py')
encoder = importlib.util.module_from_spec(spec)
spec.loader.exec_module(encoder)
for rate in (8000, 16000):
with self.subTest(rate=rate), tempfile.TemporaryDirectory() as temporary:
directory = Path(temporary)
common = [((i*997)%18001)-9000 for i in range(257)]
phrases = {'gpsOn': common+[1000,-1000]*80,
'gpsOff': common+[-3000,3000]*77}
for name, samples in phrases.items():
write_wav(directory/(name+'.wav'), samples, rate=rate)
output = directory/'shared.h'
command = [sys.executable, str(ROOT/'scripts/generate_gps_voice.py'),
'--on', str(directory/'gpsOn.wav'), '--off', str(directory/'gpsOff.wav'),
'--rate', str(rate), '--output', str(output)]
subprocess.run(command, check=True, capture_output=True, timeout=30)
source = output.read_text()
self.assertEqual(source.count('static const uint8_t '), 3)
arrays, clips = parse_header(source)
for name, samples in phrases.items():
self.assertEqual(arrays[name], encoder.encode(samples))
self.assertEqual(clips[name], (name,name,len(samples),rate))
# A completely different second phrase must not add a useless
# shared/empty blob merely to keep the nominal count at three.
write_wav(directory/'gpsOff.wav', [3000,-3000]*80, rate=rate)
subprocess.run(command, check=True, capture_output=True, timeout=30)
source = output.read_text()
self.assertEqual(source.count('static const uint8_t '), 2)
self.assertNotIn('gpsData', source)
def test_production_gps_recordings_are_the_approved_zira_audio_and_metadata(self):
source = (ROOT / 'src/helpers/ui/GpsVoiceData.h').read_text(encoding='utf-8')
self.assertEqual([line for line in source.splitlines() if line.startswith('// Voice:')],
+145
View File
@@ -0,0 +1,145 @@
"""Preserve original speech PCM/DMA output while sharing encoded flash spans."""
from pathlib import Path
import hashlib
import os
import re
import shutil
import subprocess
import tempfile
import unittest
import test_gps_voice_buttons as shared
from test_button_voice_generator import select_vibration
ROOT = Path(__file__).resolve().parents[1]
CC, CXX = shutil.which('gcc'), shutil.which('g++')
SANITIZERS = (['-fsanitize=address,undefined', '-fno-sanitize-recover=all',
'-fno-omit-frame-pointer', '-fno-pie', '-no-pie']
if os.environ.get('MESH_VOICE_TEST_SANITIZERS') == '1' else [])
# Pinned from the original contiguous approved catalogs and the original
# decoder/player before any sharing changes. PCM is s16le; DMA words are u16le
# at gain 2. These checks include every clip, final padding, IRQ refill and
# interpolation tail, not hashes derived from the implementation under test.
ORIGINAL_OUTPUT = {
(0, False): ('481630ba68b1a29d5148fb1b552ca9bb78477ddc576bf9bad6d124d193dc994c',
'7438e1cc35538956c8959adf9056aeffbd77c20e4fbd23b1204c3c17ab15a9c0'),
(0, True): ('4e7ba541d3909bf8bbc4ae94c220f3a3d6a2304efaf53e3335a0844574475e87',
'6b0419e83310946342b136661460eed5795fa92b23eb9da6f43056d840d0c025'),
(16, False): ('f61a12157647ba21320ec65fb7a4bdcee260703ca593b57e5770af45076c7972',
'f8bdd21166fe8606622abfb8cff27136612e65e61e9f18d02e95c41e62897196'),
(16, True): ('86e13b896a20c5c77ca9dae9d71c52a1da78f7603a8c8e260a6c6c74d51567d6',
'10fb34b5487048a738a75c2bd4388c4ff370cbaebb54ed3a52006738dd86f425'),
(24, False): ('e37d6bbd0c7f9ddd0018c7f50d3929b1deef27b405a7432c492b2fb67c46e11b',
'2a7815a6ea01302b0cfe2d2bb3d6a57adeeec155ba70ac8aa9e1e3965d8d54be'),
(24, True): ('59167abf199c939cc62b3b03d9dbfcffd973c495104f89de29a6dd852100cdf2',
'2915281db72ebe103e7599a797f0413eb7245346ba55879c4a0a9ca1f61be293'),
}
@unittest.skipUnless(CC and CXX, 'Native C/C++ compilers are required')
class Tests(unittest.TestCase):
def test_every_original_phrase_and_full_dma_stream_remains_bit_identical(self):
with tempfile.TemporaryDirectory() as temporary:
directory = Path(temporary)
(directory/'Arduino.h').write_text(shared.ARDUINO)
(directory/'HardwarePWM.h').write_text(shared.PWM)
for (rate, vibration), fingerprints in ORIGINAL_OUTPUT.items():
flags = ['-DMESH_BUTTON_AUDIO_HIL=1']
if rate:
flags.append(f'-DMESH_GPS_VOICE_G726_BITRATE={rate}')
if vibration:
flags.append('-DHAS_DRV2605=1')
objects = []
if rate:
obj = directory/'g726.o'
subprocess.run([CC, '-std=c99', '-Wall', '-Wextra', '-Werror',
*SANITIZERS, *flags, '-I'+str(ROOT/'src'), '-c',
str(ROOT/'src/helpers/ui/g726/g726_decoder.c'),
'-o', str(obj)], check=True, timeout=30)
objects.append(str(obj))
for pwm, fingerprint in enumerate(fingerprints):
with self.subTest(rate=rate, vibration=vibration, pwm=bool(pwm)):
binary = directory/'catalog'
subprocess.run([CXX, '-std=c++17', '-Wall', '-Wextra', '-Werror',
*SANITIZERS, *flags,
*(['-DPWM_OUTPUT=1'] if pwm else []),
'-I'+str(directory), '-I'+str(ROOT/'src'),
str(ROOT/'test/fixtures/voice_prefixes/catalog.cpp'),
*objects, '-o', str(binary)], check=True, timeout=30)
result = subprocess.run([str(binary)], check=True,
capture_output=True, timeout=30)
self.assertEqual(hashlib.sha256(result.stdout).hexdigest(), fingerprint)
def test_ima_seams_odd_lengths_truncation_and_invalid_metadata(self):
source = r'''
#include <cassert>
#include <initializer_list>
#include <limits>
#include <vector>
#include <helpers/ui/GpsVoice.h>
int main(){
using namespace mesh::audio;
const uint8_t encoded[]={0x77,0x1f,0xca,0x26,0x84,0x92,0xbb};
for(unsigned samples:{1u,2u,3u,7u,13u,14u}){
VoiceDecoder original;original.begin({encoded,sizeof(encoded),samples});
std::vector<int16_t> expected;
while(!original.done())expected.push_back(original.next());
for(size_t split=0;split<sizeof(encoded);++split){
VoiceClip clip{encoded+split,sizeof(encoded)-split,samples,8000,encoded,split};
assert(clip.valid());VoiceDecoder decoder;decoder.begin(clip);
for(auto value:expected){assert(!decoder.done());assert(decoder.next()==value);}
assert(decoder.done()&&decoder.position()==samples&&decoder.next()==0);
for(size_t tail=0;tail<sizeof(encoded)-split;++tail){
std::vector<uint8_t> prefix(encoded,encoded+split),suffix(encoded+split,encoded+split+tail);
VoiceClip short_clip{tail?suffix.data():encoded,tail,samples,8000,
split?prefix.data():nullptr,split};
decoder.begin(short_clip);
unsigned count=0;
while(!decoder.done()){assert(decoder.next()==expected[count++]);}
assert(count==((split+tail)*2<samples?(split+tail)*2:samples));
assert(short_clip.valid()==(count==samples));
}
}
}
VoiceClip bad{encoded,sizeof(encoded),14,8000,nullptr,1};
assert(!bad.valid());VoiceDecoder decoder;decoder.begin(bad);
assert(decoder.done()&&decoder.next()==0);
VoiceClip huge{encoded,std::numeric_limits<size_t>::max(),
std::numeric_limits<uint32_t>::max(),8000,encoded,1};
assert(huge.valid()&&huge.hasBytes(std::numeric_limits<size_t>::max()));
}
'''
with tempfile.TemporaryDirectory() as temporary:
directory = Path(temporary)
path, binary = directory/'seams.cpp', directory/'seams'
path.write_text(source)
subprocess.run([CXX, '-std=c++17', '-Wall', '-Wextra', '-Werror',
*SANITIZERS, '-I'+str(ROOT/'src'), str(path), '-o', str(binary)],
check=True, timeout=30)
subprocess.run([str(binary)], check=True, timeout=30)
def test_only_profitable_shared_spans_are_stored_and_optional_sound_is_gated(self):
expected = {0: (3135, 746, 1090), 16: (1535, 268, 545), 24: (1967, 427, 817)}
for rate, sizes in expected.items():
if rate:
source = (ROOT/'src/helpers/ui/G726VoiceData.h').read_text()
source = source.split(f'#if MESH_GPS_VOICE_G726_BITRATE == {rate}\n')[1]
source = source.split(f'#endif // {rate} kbps')[0]
else:
source = ((ROOT/'src/helpers/ui/GpsVoiceData.h').read_text() + '\n'
+ (ROOT/'src/helpers/ui/ButtonVoiceData.h').read_text())
for vibration in (False, True):
body = select_vibration(source, vibration)
arrays = {name:bytes.fromhex(' '.join(re.findall(r'0x([0-9a-f]{2})',data)))
for name,data in re.findall(r'static const uint8_t (\w+)Data\[\] = \{(.*?)\};',body,re.S)}
self.assertEqual(len(arrays['gps']), sizes[0])
self.assertEqual(len(arrays['advertPrefix']), sizes[1])
self.assertEqual('soundPrefix' in arrays, vibration)
if vibration:
self.assertEqual(len(arrays['soundPrefix']), sizes[2])
self.assertEqual(sum(name.startswith('gps') for name in arrays), 3)
if __name__ == '__main__':
unittest.main()