xref: /expo/apps/test-suite/tests/Brightness.js (revision 125857a1) 
1import * as Brightness from 'expo-brightness';
2import { Platform } from 'react-native';
3
4import * as TestUtils from '../TestUtils';
5
6export const name = 'Brightness';
7export const EPSILON = Math.pow(10, -5);
8
9export async function test(t) {
10  const shouldSkipTestsRequiringPermissions =
11    await TestUtils.shouldSkipTestsRequiringPermissionsAsync();
12  const describeWithPermissions = shouldSkipTestsRequiringPermissions ? t.xdescribe : t.describe;
13
14  t.describe(name, () => {
15    let originalBrightness;
16
17    t.beforeAll(async () => {
18      originalBrightness = await Brightness.getBrightnessAsync();
19    });
20
21    t.afterAll(async () => {
22      await Brightness.setBrightnessAsync(originalBrightness);
23    });
24
25    t.describe(`Brightness.getBrightnessAsync(), Brightness.setBrightnessAsync()`, () => {
26      t.it(`gets and sets the current brightness of the app screen`, async () => {
27        const originalValue = 0.2;
28        let wasRejected = false;
29        try {
30          await Brightness.setBrightnessAsync(originalValue);
31        } catch {
32          wasRejected = true;
33        }
34        const obtainedValue = await Brightness.getBrightnessAsync();
35        t.expect(Math.abs(originalValue - obtainedValue)).toBeLessThan(EPSILON);
36        t.expect(wasRejected).toBe(false);
37      });
38
39      t.it(
40        `set to the lowest brightness when the values passed to the setter are too low`,
41        async () => {
42          const tooLowValue = -0.1;
43          let wasRejected = false;
44          try {
45            await Brightness.setBrightnessAsync(tooLowValue);
46          } catch {
47            wasRejected = true;
48          }
49          const obtainedValue = await Brightness.getBrightnessAsync();
50          t.expect(Math.abs(0 - obtainedValue)).toBeLessThan(EPSILON);
51          t.expect(wasRejected).toBe(false);
52        }
53      );
54
55      t.it(
56        `set to the highest brightness when the values passed to the setter are too high`,
57        async () => {
58          const tooHighValue = 1.1;
59          let wasRejected = false;
60          try {
61            await Brightness.setBrightnessAsync(tooHighValue);
62          } catch {
63            wasRejected = true;
64          }
65          const obtainedValue = await Brightness.getBrightnessAsync();
66          t.expect(Math.abs(1 - obtainedValue)).toBeLessThan(EPSILON);
67          t.expect(wasRejected).toBe(false);
68        }
69      );
70
71      t.it(`throws when NaN is passed to the setter`, async () => {
72        let wasRejected = false;
73        try {
74          await Brightness.setBrightnessAsync(NaN);
75        } catch {
76          wasRejected = true;
77        }
78        t.expect(wasRejected).toBe(true);
79      });
80    });
81
82    if (Platform.OS === 'ios') {
83      t.describe(`Event listeners`, () => {
84        t.it(`addBrightnessListener() registers`, () => {
85          const listener = Brightness.addBrightnessListener(({ brightness }) => {
86            console.log('brightness changed!', brightness);
87          });
88          t.expect(listener).toBeDefined();
89          listener.remove();
90        });
91      });
92    }
93
94    if (Platform.OS === 'android') {
95      describeWithPermissions(
96        `Brightness.getSystemBrightnessAsync(), Brightness.setSystemBrightnessAsync()`,
97        () => {
98          t.beforeAll(async () => {
99            await TestUtils.acceptPermissionsAndRunCommandAsync(() => {
100              return Brightness.requestPermissionsAsync();
101            });
102          });
103
104          t.it(`gets and sets the current system brightness`, async () => {
105            const originalValue = 0.2;
106            let wasRejected = false;
107            try {
108              await Brightness.setSystemBrightnessAsync(originalValue);
109            } catch {
110              wasRejected = true;
111            }
112            const obtainedValue = await Brightness.getSystemBrightnessAsync();
113            t.expect(Math.abs(originalValue - obtainedValue)).toBeLessThan(EPSILON);
114            t.expect(wasRejected).toBe(false);
115          });
116
117          t.it(
118            `set to the lowest brightness when the values passed to the setter are too low`,
119            async () => {
120              const tooLowValue = -0.1;
121              let wasRejected = false;
122              try {
123                await Brightness.setSystemBrightnessAsync(tooLowValue);
124              } catch {
125                wasRejected = true;
126              }
127              const obtainedValue = await Brightness.getSystemBrightnessAsync();
128              t.expect(Math.abs(0 - obtainedValue)).toBeLessThan(EPSILON);
129              t.expect(wasRejected).toBe(false);
130            }
131          );
132
133          t.it(
134            `set to the highest brightness when the values passed to the setter are too high`,
135            async () => {
136              const tooHighValue = 1.1;
137              let wasRejected = false;
138              try {
139                await Brightness.setSystemBrightnessAsync(tooHighValue);
140              } catch {
141                wasRejected = true;
142              }
143              const obtainedValue = await Brightness.getSystemBrightnessAsync();
144              t.expect(Math.abs(1 - obtainedValue)).toBeLessThan(EPSILON);
145              t.expect(wasRejected).toBe(false);
146            }
147          );
148
149          t.it(`throws when NaN is passed to the setter`, async () => {
150            let wasRejected = false;
151            try {
152              await Brightness.setSystemBrightnessAsync(NaN);
153            } catch {
154              wasRejected = true;
155            }
156            t.expect(wasRejected).toBe(true);
157          });
158        }
159      );
160
161      describeWithPermissions(`Brightness.useSystemBrightnessAsync`, () => {
162        t.beforeAll(async () => {
163          await TestUtils.acceptPermissionsAndRunCommandAsync(() => {
164            return Brightness.requestPermissionsAsync();
165          });
166        });
167
168        t.beforeEach(async () => {
169          const cleanValue = 0.5;
170          await Brightness.setBrightnessAsync(cleanValue);
171          await Brightness.setSystemBrightnessAsync(cleanValue);
172        });
173
174        t.it(`makes the current activity use the system brightness`, async () => {
175          const appValue = 0;
176          const systemValue = 1;
177          let wasRejected = false;
178          try {
179            await Brightness.setSystemBrightnessAsync(systemValue);
180            await Brightness.setBrightnessAsync(appValue);
181            await Brightness.useSystemBrightnessAsync();
182          } catch {
183            wasRejected = true;
184          }
185          const obtainedValue = await Brightness.getBrightnessAsync();
186          t.expect(Math.abs(obtainedValue - systemValue)).toBeLessThan(EPSILON);
187          t.expect(wasRejected).toBe(false);
188        });
189
190        t.it(`is overridden by setting the app brightness`, async () => {
191          const appValue = 0;
192          const systemValue = 1;
193          let wasRejected = false;
194          try {
195            await Brightness.setSystemBrightnessAsync(systemValue);
196            await Brightness.useSystemBrightnessAsync();
197            await Brightness.setBrightnessAsync(appValue);
198          } catch {
199            wasRejected = true;
200          }
201          const obtainedValue = await Brightness.getBrightnessAsync();
202          t.expect(Math.abs(obtainedValue - appValue)).toBeLessThan(EPSILON);
203          t.expect(wasRejected).toBe(false);
204        });
205      });
206
207      describeWithPermissions(`Brightness.isUsingSystemBrightnessAsync`, () => {
208        t.beforeAll(async () => {
209          await TestUtils.acceptPermissionsAndRunCommandAsync(() => {
210            return Brightness.requestPermissionsAsync();
211          });
212        });
213
214        t.beforeEach(async () => {
215          const cleanValue = 0.5;
216          await Brightness.setBrightnessAsync(cleanValue);
217          await Brightness.setSystemBrightnessAsync(cleanValue);
218        });
219
220        t.it(
221          `returns a boolean specifiying whether or not the current activity is using the system brightness`,
222          async () => {
223            let wasRejected = false;
224            const beforeValue = await Brightness.isUsingSystemBrightnessAsync();
225            try {
226              await Brightness.useSystemBrightnessAsync();
227            } catch {
228              wasRejected = true;
229            }
230            const afterValue = await Brightness.isUsingSystemBrightnessAsync();
231            t.expect(beforeValue).toBe(false);
232            t.expect(afterValue).toBe(true);
233            t.expect(wasRejected).toBe(false);
234          }
235        );
236      });
237
238      describeWithPermissions(`Brightness Mode`, () => {
239        t.beforeAll(async () => {
240          await TestUtils.acceptPermissionsAndRunCommandAsync(() => {
241            return Brightness.requestPermissionsAsync();
242          });
243        });
244
245        t.it(`is unaffected by setting the app brightness`, async () => {
246          let wasRejected = false;
247          try {
248            await Brightness.setSystemBrightnessModeAsync(Brightness.BrightnessMode.MANUAL);
249            await Brightness.setBrightnessAsync(0.5);
250          } catch {
251            wasRejected = true;
252          }
253          let obtainedValue = await Brightness.getSystemBrightnessModeAsync();
254          t.expect(obtainedValue).toEqual(Brightness.BrightnessMode.MANUAL);
255          try {
256            await Brightness.setSystemBrightnessModeAsync(Brightness.BrightnessMode.AUTOMATIC);
257            await Brightness.setBrightnessAsync(0.5);
258          } catch {
259            wasRejected = true;
260          }
261          obtainedValue = await Brightness.getSystemBrightnessModeAsync();
262          t.expect(obtainedValue).toEqual(Brightness.BrightnessMode.AUTOMATIC);
263          t.expect(wasRejected).toBe(false);
264        });
265
266        t.it(`is set to MANUAL after setting the system brightness`, async () => {
267          let wasRejected = false;
268          try {
269            await Brightness.setSystemBrightnessModeAsync(Brightness.BrightnessMode.AUTOMATIC);
270            await Brightness.setSystemBrightnessAsync(0.5);
271          } catch {
272            wasRejected = true;
273          }
274          const obtainedValue = await Brightness.getSystemBrightnessModeAsync();
275          t.expect(obtainedValue).toEqual(Brightness.BrightnessMode.MANUAL);
276          t.expect(wasRejected).toBe(false);
277        });
278      });
279    }
280  });
281}
282