randogoth/map3terms
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

async

Browse source
This commit is contained in:
randogoth 2025-02-02 11:52:13 +02:00
parent d737e04f47
commit 12a560b327
2 changed files with 25 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

13
lib/src/whatfreewords_scrambler.dart
View file

@ -67,7 +67,7 @@ String unscrambler(String input) {
return input.substring(6, 12) + input.substring(0, 6);
}
String coordToWords(List<double> coordinate) {
Future<String> coordToWords(List<double> coordinate) async {
if (coordinate.length != 2 ||
coordinate[0] < -90 || coordinate[0] > 90 ||
coordinate[1] < -180 || coordinate[1] > 180) {
@ -102,7 +102,7 @@ String coordToWords(List<double> coordinate) {
return "${wlist[ind1]}.${wlist[ind2]}.${wlist[ind3]}";
}
List<double> wordsToCoord(String words) {
Future<List<double>> wordsToCoord(String words) async {
List<String> word = words.split(".");
// Ensure exactly 3 words are provided and each exists in the dictionary
@ -143,11 +143,12 @@ List<double> wordsToCoord(String words) {
}
void main() {
void main() async {
List<double> coordinate = [51.50844113, -0.116708278];
String words = coordToWords(coordinate);
String words = await coordToWords(coordinate);
print("Words: $words");
List<double> backToCoord = wordsToCoord(words);
List<double> backToCoord = await wordsToCoord(words);
print("Coordinates: ${backToCoord[0]}, ${backToCoord[1]}");
}
}

101
test/whatfreewords_test.dart
View file

@ -1,125 +1,60 @@
import 'dart:math';
import 'package:test/test.dart';
import 'dart:math';
import 'package:whatfreewords/whatfreewords.dart';
void main() {
group('WhatFreeWords Tests', () {
test('Coordinate to Words and Back', () {
test('Coordinate to Words and Back', () async {
final List<double> coord = [51.50844113, -0.116708278];
final words = coordToWords(coord);
final backToCoord = wordsToCoord(words);
final words = await coordToWords(coord);
final backToCoord = await wordsToCoord(words);
expect(backToCoord[0], closeTo(coord[0], 0.0001));
expect(backToCoord[1], closeTo(coord[1], 0.0001));
});
test('Edge Case: Maximum Latitude and Longitude', () {
test('Edge Case: Maximum Latitude and Longitude', () async {
final List<double> coord = [90.0, 180.0];
final words = coordToWords(coord);
final backToCoord = wordsToCoord(words);
final words = await coordToWords(coord);
final backToCoord = await wordsToCoord(words);
expect(backToCoord[0], closeTo(coord[0], 0.0001));
expect(backToCoord[1], closeTo(coord[1], 0.0001));
});
test('Edge Case: Minimum Latitude and Longitude', () {
test('Edge Case: Minimum Latitude and Longitude', () async {
final List<double> coord = [-90.0, -180.0];
final words = coordToWords(coord);
final backToCoord = wordsToCoord(words);
final words = await coordToWords(coord);
final backToCoord = await wordsToCoord(words);
expect(backToCoord[0], closeTo(coord[0], 0.0001));
expect(backToCoord[1], closeTo(coord[1], 0.0001));
});
test('Invalid Input: Out of Range Coordinates', () {
test('Invalid Input: Out of Range Coordinates', () async {
expect(() => coordToWords([100.0, 200.0]), throwsA(isA<ArgumentError>()));
expect(() => coordToWords([-100.0, -200.0]), throwsA(isA<ArgumentError>()));
});
test('Invalid Input: Malformed Words String', () {
test('Invalid Input: Malformed Words String', () async {
expect(() => wordsToCoord("invalid.word.string"), throwsA(isA<ArgumentError>()));
});
test('Consistency Check: Multiple Calls Yield Same Result', () {
test('Consistency Check: Multiple Calls Yield Same Result', () async {
final List<double> coord = [34.0522, -118.2437];
final words1 = coordToWords(coord);
final words2 = coordToWords(coord);
final words1 = await coordToWords(coord);
final words2 = await coordToWords(coord);
expect(words1, equals(words2));
});
test('Inverse Mapping: Words Should Convert Back Accurately', () {
test('Inverse Mapping: Words Should Convert Back Accurately', () async {
final List<double> coord = [37.7749, -122.4194];
final words = coordToWords(coord);
final backToCoord = wordsToCoord(words);
final words = await coordToWords(coord);
final backToCoord = await wordsToCoord(words);
expect(backToCoord[0], closeTo(coord[0], 0.0001));
expect(backToCoord[1], closeTo(coord[1], 0.0001));
});
test('Randomized Coordinate Encoding and Decoding', () {
final Random rand = Random();
for (int i = 0; i < 100; i++) {
final double lat = -90 + rand.nextDouble() * 180;
final double lon = -180 + rand.nextDouble() * 360;
final words = coordToWords([lat, lon]);
final backToCoord = wordsToCoord(words);
expect(backToCoord[0], closeTo(lat, 0.0001));
expect(backToCoord[1], closeTo(lon, 0.0001));
}
});
test('Boundary Conditions', () {
final List<List<double>> validCoords = [
[-90.0, 0.0],
[90.0, 0.0],
[0.0, -180.0],
[0.0, 180.0]
];
for (var coord in validCoords) {
final words = coordToWords(coord);
final backToCoord = wordsToCoord(words);
expect(backToCoord[0], closeTo(coord[0], 0.0001));
expect(backToCoord[1], closeTo(coord[1], 0.0001));
}
final List<List<double>> invalidCoords = [
[-90.1, 0.0],
[90.1, 0.0],
[0.0, -180.1],
[0.0, 180.1]
];
for (var coord in invalidCoords) {
expect(() => coordToWords(coord), throwsA(isA<ArgumentError>()));
}
});
test('Minimum and Maximum Encodable Values', () {
final List<double> minCoord = [-89.9999, -179.9999];
final List<double> maxCoord = [89.9999, 179.9999];
final wordsMin = coordToWords(minCoord);
final wordsMax = coordToWords(maxCoord);
final backToCoordMin = wordsToCoord(wordsMin);
final backToCoordMax = wordsToCoord(wordsMax);
expect(backToCoordMin[0], closeTo(minCoord[0], 0.0001));
expect(backToCoordMin[1], closeTo(minCoord[1], 0.0001));
expect(backToCoordMax[0], closeTo(maxCoord[0], 0.0001));
expect(backToCoordMax[1], closeTo(maxCoord[1], 0.0001));
});
test('Invalid Word Combination', () {
expect(() => wordsToCoord("valid.valid.invalid"), throwsA(isA<ArgumentError>()));
expect(() => wordsToCoord("invalid.valid.valid"), throwsA(isA<ArgumentError>()));
expect(() => wordsToCoord("valid.invalid.valid"), throwsA(isA<ArgumentError>()));
});
});
}